diff --git a/.craft.yml b/.craft.yml
index 8fe0ac390..5d4e54e4c 100644
--- a/.craft.yml
+++ b/.craft.yml
@@ -21,4 +21,4 @@ requireNames:
   - /^symbolic-.*-py2.py3-none-macosx_11_0_arm64.whl$/
   - /^symbolic-.*-py2.py3-none-manylinux_2_28_aarch64.whl$/
   - /^symbolic-.*-py2.py3-none-manylinux_2_28_x86_64.whl$/
-  - /^symbolic-.*.zip$/
+  - /^symbolic-.*.tar.gz$/
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 5d137aba4..671345120 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -7,6 +7,8 @@ on:
 
 env:
   MANYLINUX_VERSION: manylinux_2_28
+  # Pinned to 2025.08.15-1 since manylinux 2025.08.22 onward removes setuptools
+  MANYLINUX_PIN: 2025.08.15-1
 
 jobs:
   python-wheel-mac:
@@ -36,10 +38,13 @@ jobs:
           # consumed by cargo and setup.py to obtain the target dir
           CARGO_BUILD_TARGET: ${{ matrix.target }}
 
-      - uses: actions/upload-artifact@v3.1.1
+      - uses: actions/upload-artifact@v4
         with:
-          name: ${{ github.sha }}
+          name: artifact-macos-${{ matrix.target }}
           path: py/dist/*
+          if-no-files-found: "error"
+          # since this artifact will be merged, compression is not necessary
+          compression-level: "0"
 
   python-wheel-linux:
     strategy:
@@ -61,12 +66,15 @@ jobs:
 
       - if: matrix.build-arch == 'x86_64'
         name: Build in Docker (x86_64)
-        run: make wheel-manylinux IMAGE=quay.io/pypa/"$MANYLINUX_VERSION"_x86_64
+        run: make wheel-manylinux IMAGE=quay.io/pypa/"$MANYLINUX_VERSION"_x86_64:"$MANYLINUX_PIN"
 
-      - uses: actions/upload-artifact@v3.1.1
+      - uses: actions/upload-artifact@v4
         with:
-          name: ${{ github.sha }}
+          name: artifact-linux-${{ matrix.build-arch }}
           path: py/dist/*
+          if-no-files-found: "error"
+          # since this artifact will be merged, compression is not necessary
+          compression-level: "0"
 
   sdist:
     name: Python sdist
@@ -81,7 +89,22 @@ jobs:
 
       - run: make sdist
 
-      - uses: actions/upload-artifact@v3.1.1
+      - uses: actions/upload-artifact@v4
         with:
-          name: ${{ github.sha }}
+          name: artifact-sdist
           path: py/dist/*
+          if-no-files-found: "error"
+          # since this artifact will be merged, compression is not necessary
+          compression-level: "0"
+
+  merge:
+    name: Create Release Artifact
+    runs-on: ubuntu-latest
+    needs: [python-wheel-linux, python-wheel-mac, sdist]
+    steps:
+      - uses: actions/upload-artifact/merge@v4
+        with:
+          # Craft expects release assets from github to be a single artifact named after the sha.
+          name: ${{ github.sha }}
+          pattern: artifact-*
+          delete-merged: true
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 483f1e3de..34325cc17 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -54,7 +54,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
 
     name: Rust Test on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
diff --git a/.github/workflows/danger.yml b/.github/workflows/danger.yml
index e24696d75..d00032569 100644
--- a/.github/workflows/danger.yml
+++ b/.github/workflows/danger.yml
@@ -2,8 +2,10 @@ name: Danger
 
 on:
   pull_request:
-    types: [opened, synchronize, reopened, edited, ready_for_review]
+    types: [opened, synchronize, reopened, edited, ready_for_review, labeled, unlabeled]
 
 jobs:
   danger:
-    uses: getsentry/github-workflows/.github/workflows/danger.yml@v2
+    runs-on: ubuntu-latest
+    steps:
+      - uses: getsentry/github-workflows/danger@v3
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index a523379b8..e3290798f 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -15,9 +15,16 @@ jobs:
     runs-on: ubuntu-latest
     name: "Release a new version"
     steps:
+      - name: Get auth token
+        id: token
+        uses: actions/create-github-app-token@5d869da34e18e7287c1daad50e0b8ea0f506ce69 # v1.11.0
+        with:
+          app-id: ${{ vars.SENTRY_RELEASE_BOT_CLIENT_ID }}
+          private-key: ${{ secrets.SENTRY_RELEASE_BOT_PRIVATE_KEY }}
+
       - uses: actions/checkout@v3
         with:
-          token: ${{ secrets.GH_RELEASE_PAT }}
+          token: ${{ steps.token.outputs.token }}
           fetch-depth: 0
 
       - run: rustup toolchain install stable --profile minimal --no-self-update
@@ -25,7 +32,7 @@ jobs:
       - name: Prepare release
         uses: getsentry/action-prepare-release@v1
         env:
-          GITHUB_TOKEN: ${{ secrets.GH_RELEASE_PAT }}
+          GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:
           version: ${{ github.event.inputs.version }}
           force: ${{ github.event.inputs.force }}
diff --git a/.semgrepignore b/.semgrepignore
new file mode 100644
index 000000000..b192bacd5
--- /dev/null
+++ b/.semgrepignore
@@ -0,0 +1,4 @@
+:include .gitignore
+
+examples/
+**/tests/
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
index 555377c1d..afb8e346b 100644
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -5,14 +5,15 @@
         // C++ language support
         "ms-vscode.cpptools",
         // TOML language support
-        "bungcip.better-toml",
+        "tamasfe.even-better-toml",
         // Rust language server
         "rust-lang.rust-analyzer",
         // Crates.io dependency versions
-        "serayuzgur.crates",
+        "fill-labs.dependi",
         // Debugger support for Rust and native
         "vadimcn.vscode-lldb",
         // PEST syntax support
         "xoronic.pestfile"
+
     ]
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 869ec8af1..3f318d5f2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,173 @@
 # Changelog
 
+## 12.17.0
+
+- feat(pdb): Extract the srcsrv integration name for metrics ([#944](https://github.com/getsentry/symbolic/pull/944))
+
+## 12.16.3
+
+- feat(elf): Added support for dynamic symbols when DYNAMIC segment is missing. ([#935](https://github.com/getsentry/symbolic/pull/935))
+- fix(dwarf): -2 is now an allowed tombstone address in some DWARF sections.
+  For details, see https://github.com/gimli-rs/gimli/pull/791. ([#937](https://github.com/getsentry/symbolic/pull/937)).
+
+## 12.16.2
+
+**Fixes**
+
+- sourcemapcache: Tokens are now considered to only extend to the end of the line
+  (as intended). This means that some lookups that would previously (incorrectly)
+  have returned unminified source positions now return nothing. ([#932](https://github.com/getsentry/symbolic/pull/932))
+
+## 12.16.1
+
+**Fixes**
+
+- symcache: Fixed a bug in symcache generation for functions without line records. ([#930](https://github.com/getsentry/symbolic/pull/930))
+
+## 12.16.0
+
+**Features**
+
+- python bindings: Expose SourceMapView.get_source_contents function. ([#921](https://github.com/getsentry/symbolic/pull/921))
+- Change the MSRV version to 1.82. ([#927](https://github.com/getsentry/symbolic/pull/927))
+- build: switch to Python3.11 for releases builds. ([#929](https://github.com/getsentry/symbolic/pull/929))
+
+**Fixes**
+
+- sourcemapcache: Don't return unmapped source locations. ([#922](https://github.com/getsentry/symbolic/pull/922))
+
+## 12.15.5
+
+**Fixes**
+
+- demangle: Fixed a crash/abort when providing bad input to the swift demangler. ([#917](https://github.com/getsentry/symbolic/pull/917))
+
+## 12.15.4
+
+**Fixes**
+
+- symcache: Fixed a bug introduced in 12.14.0 that resulted in symbols not being inserted. ([#915](https://github.com/getsentry/symbolic/pull/915))
+
+## 12.15.3
+
+**Features**
+
+- Allow specifying multiple symbol sources in minidump-stackwalk utility. ([#903](https://github.com/getsentry/symbolic/pull/903))
+- Add a subcommand to extract individual files from a unreal crash report to the `unreal_engine_crash` utility. ([#907](https://github.com/getsentry/symbolic/pull/907))
+
+**Fixes**
+
+- Do not hallucinate frames when stack walking in minidump-stackwalk utility. ([#904](https://github.com/getsentry/symbolic/pull/904))
+
+**Improvements**
+
+- Add normalization for paths in `FileKey`. ([#908](https://github.com/getsentry/symbolic/pull/908))
+
+## 12.14.1
+
+**Fixes**
+
+- Restore support for older Rust versions and clarify MSRV policy. ([#902](https://github.com/getsentry/symbolic/pull/902))
+
+## 12.14.0
+
+**Features**
+
+- Expose API to apply access pattern hints to a `ByteView`.([#899](https://github.com/getsentry/symbolic/pull/899)).
+
+**Fixes**
+
+- symcache: Explicitly map "holes" between functions ([#897](https://github.com/getsentry/symbolic/pull/897))
+
+## 12.13.4
+
+**Fixes**
+
+- Parse `debug_str_offs` section in Mach-O files ([#895](https://github.com/getsentry/symbolic/pull/895))
+
+## 12.13.3
+
+**Improvements**
+
+- Check UTF-8 validity memory efficiently ([#890](https://github.com/getsentry/symbolic/pull/890))
+
+## 12.13.2
+
+**Fixes**
+
+- Fixed GHA-based Windows builds ([#891](https://github.com/getsentry/symbolic/pull/891)).
+
+## 12.13.1
+
+**Fixes**
+
+- Fixed a compilation issue with older GCC compilers. ([#886](https://github.com/getsentry/symbolic/pull/886))
+
+## 12.13.0
+
+**Features**
+
+- Updated libswift demangle to v6.0.3. ([#885](https://github.com/getsentry/symbolic/pull/885))
+
+## 12.12.4
+
+**Fixes**
+
+- symcache: Fixed a bug related to to inlinee resolution during symcache conversion. ([#883](https://github.com/getsentry/symbolic/pull/883))
+
+## 12.12.3
+
+**Fixes**
+
+- js: Prefer `"debug_id"` for sourcemap debug IDs. ([#878](https://github.com/getsentry/symbolic/pull/878)).
+
+## 12.12.2
+
+**Fixes**
+
+- js: Fixed an error when reading debug IDs from sourcemaps with
+  both `"debugId"` and `"debug_id"` keys ([#877](https://github.com/getsentry/symbolic/pull/877)).
+
+## 12.12.1
+
+**Features**
+
+- feat(js): Sourcemap debug IDs can now be read from the `"debugId"` field in addition to
+  `"debug_id"` ([#870](https://github.com/getsentry/symbolic/pull/870)).
+
+## 12.12.0
+
+**Fixes**
+
+- Unship "Support for DWARFv5 embedded source code extension ([#849](https://github.com/getsentry/symbolic/pull/849))".
+  Unfortunately the check for whether an elf file contains embedded sources is prohibitively expensive in terms of memory.
+  ([#870](https://github.com/getsentry/symbolic/pull/870))
+
+## 12.11.1
+
+**Fixes**
+
+- symbolic-cfi: Skip invalid FDEs when converting DWARF to Breakpad CFI ([#868](https://github.com/getsentry/symbolic/pull/868))
+
+**Internal**:
+
+- Removed `dmsort` dependency and replaced uses with stable std sorts. ([#869](https://github.com/getsentry/symbolic/pull/869))
+
+## 12.11.0
+
+- Add callback to `symbolic::debuginfo::sourcebundle::SourceBundleWriter` which handles files skipped while writing to the source bundle. ([#864](https://github.com/getsentry/symbolic/pull/864))
+
+## 12.10.1
+
+- Skip invalid sources ([#861](https://github.com/getsentry/symbolic/pull/861))
+
+## 12.10.0
+
+**Features**
+
+- Support for DWARFv5 embedded source code extension ([#849](https://github.com/getsentry/symbolic/pull/849))
+- Updated wasmparser dependency to 0.214.0 ([#849](https://github.com/getsentry/symbolic/pull/853))
+
 ## 12.9.2
 
 - Downgrade and pin `zip` to fix SourceBundles with >64k files ([#846](https://github.com/getsentry/symbolic/pull/846))
diff --git a/Cargo.lock b/Cargo.lock
index 08e5694e2..924a709f0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,29 +1,10 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "Inflector"
-version = "0.11.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
-dependencies = [
- "lazy_static",
- "regex",
-]
-
-[[package]]
-name = "addr2line"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
-dependencies = [
- "gimli 0.29.0",
-]
+version = 4
 
 [[package]]
 name = "addr2line"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "anyhow",
  "clap",
@@ -31,16 +12,16 @@ dependencies = [
 ]
 
 [[package]]
-name = "adler"
-version = "1.0.2"
+name = "adler2"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "ahash"
-version = "0.8.11"
+version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -50,18 +31,18 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "android-tzdata"
-version = "0.1.1"
+name = "allocator-api2"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
 [[package]]
 name = "android_system_properties"
@@ -80,9 +61,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anstream"
-version = "0.6.14"
+version = "0.6.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418c75fa768af9c03be99d17643f93f79bbba589895012a80e3452a19ddda15b"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -95,43 +76,44 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.7"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.4"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.0.3"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a64c907d4e79225ac72e2a354c9ce84d50ebb4586dee56c82b3ee73004f537f5"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.3"
+version = "3.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
- "windows-sys 0.52.0",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.86"
+version = "1.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
+checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
 
 [[package]]
 name = "anylog"
@@ -144,28 +126,36 @@ dependencies = [
  "regex",
 ]
 
+[[package]]
+name = "ar_archive_writer"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0c269894b6fe5e9d7ada0cf69b5bf847ff35bc25fc271f08e1d080fce80339a"
+dependencies = [
+ "object",
+]
+
 [[package]]
 name = "arbitrary"
-version = "1.3.2"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
 dependencies = [
  "derive_arbitrary",
 ]
 
 [[package]]
 name = "arrayvec"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "ast_node"
-version = "0.9.8"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ab31376d309dd3bfc9cfb3c11c93ce0e0741bbe0354b20e7f8c60b044730b79"
+checksum = "2eb025ef00a6da925cf40870b9c8d008526b6004ece399cb0974209720f0b194"
 dependencies = [
- "proc-macro2",
  "quote",
  "swc_macros_common",
  "syn",
@@ -173,9 +163,9 @@ dependencies = [
 
 [[package]]
 name = "async-trait"
-version = "0.1.80"
+version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -184,39 +174,25 @@ dependencies = [
 
 [[package]]
 name = "autocfg"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
-
-[[package]]
-name = "backtrace"
-version = "0.3.72"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17c6a35df3749d2e8bb1b7b21a976d82b15548788d2735b9d82f329268f71a11"
-dependencies = [
- "addr2line 0.22.0",
- "cc",
- "cfg-if",
- "libc",
- "miniz_oxide",
- "object",
- "rustc-demangle",
-]
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "base64-simd"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "781dd20c3aff0bd194fe7d2a977dd92f21c173891f3a03b677359e5fa457e5d5"
+checksum = "339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195"
 dependencies = [
- "simd-abstraction",
+ "outref",
+ "vsimd",
 ]
 
 [[package]]
 name = "better_scoped_tls"
-version = "0.1.1"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "794edcc9b3fb07bb4aecaa11f093fd45663b4feadb782d68303a2268bc2701de"
+checksum = "7cd228125315b132eed175bf47619ac79b945b26e56b848ba203ae4ea8603609"
 dependencies = [
  "scoped-tls",
 ]
@@ -227,6 +203,21 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "597bb81c80a54b6a4381b23faba8d7774b144c94cbd1d6fe3f1329bd776554ab"
 
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -235,9 +226,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.5.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
 
 [[package]]
 name = "bitvec"
@@ -253,9 +244,9 @@ dependencies = [
 
 [[package]]
 name = "breakpad-symbols"
-version = "0.21.2"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b37cb0d96cbe2c0cb6c4fc8856dc38b87d61abaa220c818f162bee332d3f4193"
+checksum = "61f012b493245d982c24a716dd716d06188af966f685ce3cafe02e197ab7fb59"
 dependencies = [
  "async-trait",
  "cachemap2",
@@ -265,7 +256,7 @@ dependencies = [
  "minidump-common",
  "nom",
  "range-map",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
 ]
 
@@ -280,26 +271,36 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "0.2.17"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
 dependencies = [
- "lazy_static",
  "memchr",
- "regex-automata 0.1.10",
+ "regex-automata",
+ "serde",
 ]
 
 [[package]]
 name = "bumpalo"
-version = "3.16.0"
+version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
 [[package]]
 name = "bytes"
-version = "1.6.0"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
+
+[[package]]
+name = "bytes-str"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
+checksum = "7c60b5ce37e0b883c37eb89f79a1e26fbe9c1081945d024eee93e8d91a7e18b3"
+dependencies = [
+ "bytes",
+ "serde",
+]
 
 [[package]]
 name = "cachemap2"
@@ -315,32 +316,32 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.0.98"
+version = "1.2.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41c270e7540d725e65ac7f1b212ac8ce349719624d7bcff99f8e2e488e8cf03f"
+checksum = "c481bdbf0ed3b892f6f806287d72acd515b352a4ec27a208489b8c1bc839633a"
 dependencies = [
+ "find-msvc-tools",
  "jobserver",
  "libc",
- "once_cell",
+ "shlex",
 ]
 
 [[package]]
 name = "cfg-if"
-version = "1.0.0"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "chrono"
-version = "0.4.38"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
 dependencies = [
- "android-tzdata",
  "iana-time-zone",
  "num-traits",
  "serde",
- "windows-targets 0.52.5",
+ "windows-link",
 ]
 
 [[package]]
@@ -378,18 +379,18 @@ checksum = "b0fc239e0f6cb375d2402d48afb92f76f5404fd1df208a41930ec81eda078bea"
 
 [[package]]
 name = "clap"
-version = "4.5.4"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90bc066a67923782aa8515dbaea16946c5bcc5addbd668bb80af688e53e548a0"
+checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8"
 dependencies = [
  "clap_builder",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.5.2"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae129e2e766ae0ec03484e609954119f123cc1fe650337e155d03b022f24f7b4"
+checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00"
 dependencies = [
  "anstream",
  "anstyle",
@@ -399,48 +400,48 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.7.0"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce"
+checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "colorchoice"
-version = "1.0.1"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 
 [[package]]
 name = "console"
-version = "0.15.8"
+version = "0.15.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
 dependencies = [
  "encode_unicode",
- "lazy_static",
  "libc",
- "windows-sys 0.52.0",
+ "once_cell",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "cpp_demangle"
-version = "0.4.3"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e8227005286ec39567949b33df9896bcadfa6051bccca2488129f108ca23119"
+checksum = "f2bb79cb74d735044c972aae58ed0aaa9a837e85b01106a54c39e42e97f62253"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "crc32fast"
-version = "1.4.2"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
  "cfg-if",
 ]
@@ -483,9 +484,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -502,9 +503,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.20"
+version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "crossterm"
@@ -512,7 +513,7 @@ version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f476fe445d41c9e991fd07515a6f463074b782242ccf4a5b7b1d1012e70824df"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.10.0",
  "crossterm_winapi",
  "libc",
  "mio",
@@ -533,15 +534,15 @@ dependencies = [
 
 [[package]]
 name = "crunchy"
-version = "0.2.2"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
 name = "data-encoding"
-version = "2.6.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
 
 [[package]]
 name = "debugid"
@@ -555,7 +556,7 @@ dependencies = [
 
 [[package]]
 name = "debuginfo_debug"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "anyhow",
  "clap",
@@ -564,18 +565,18 @@ dependencies = [
 
 [[package]]
 name = "deranged"
-version = "0.3.11"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"
 dependencies = [
  "powerfmt",
 ]
 
 [[package]]
 name = "derive_arbitrary"
-version = "1.3.2"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
+checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -584,24 +585,18 @@ dependencies = [
 
 [[package]]
 name = "displaydoc"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
-[[package]]
-name = "dmsort"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0bc8fbe9441c17c9f46f75dfe27fa1ddb6c68a461ccaed0481419219d4f10d3"
-
 [[package]]
 name = "dump_cfi"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "anyhow",
  "clap",
@@ -610,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "dump_sources"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "clap",
  "symbolic",
@@ -618,9 +613,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.12.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
 [[package]]
 name = "elementtree"
@@ -633,42 +628,42 @@ dependencies = [
 
 [[package]]
 name = "elsa"
-version = "1.10.0"
+version = "1.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d98e71ae4df57d214182a2e5cb90230c0192c6ddfcaa05c36453d46a54713e10"
+checksum = "9abf33c656a7256451ebb7d0082c5a471820c31269e49d807c538c252352186e"
 dependencies = [
  "stable_deref_trait",
 ]
 
 [[package]]
 name = "encode_unicode"
-version = "0.3.6"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
 
 [[package]]
 name = "encoding_rs"
-version = "0.8.34"
+version = "0.8.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "equivalent"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "errno"
-version = "0.3.9"
+version = "0.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -685,36 +680,47 @@ checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 
 [[package]]
 name = "fastrand"
-version = "2.1.0"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
+checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
 
 [[package]]
 name = "flate2"
-version = "1.0.30"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae"
+checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
 ]
 
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
 [[package]]
 name = "form_urlencoded"
-version = "1.2.1"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
 dependencies = [
  "percent-encoding",
 ]
 
 [[package]]
 name = "from_variant"
-version = "0.1.8"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdc9cc75639b041067353b9bce2450d6847e547276c6fbe4487d7407980e07db"
+checksum = "e5ff35a391aef949120a0340d690269b3d9f63460a6106e99bd07b961f345ea9"
 dependencies = [
- "proc-macro2",
  "swc_macros_common",
  "syn",
 ]
@@ -727,15 +733,15 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "futures-core"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
 [[package]]
 name = "futures-macro"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -744,15 +750,15 @@ dependencies = [
 
 [[package]]
 name = "futures-task"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
 
 [[package]]
 name = "futures-util"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
  "futures-core",
  "futures-macro",
@@ -763,16 +769,22 @@ dependencies = [
 ]
 
 [[package]]
-name = "gimli"
-version = "0.29.0"
+name = "getrandom"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
 
 [[package]]
 name = "gimli"
-version = "0.30.0"
+version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e1d97fbe9722ba9bbd0c97051c2956e726562b61f86a25a4360398a40edfc9"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 dependencies = [
  "fallible-iterator 0.3.0",
  "stable_deref_trait",
@@ -791,12 +803,13 @@ dependencies = [
 
 [[package]]
 name = "half"
-version = "2.4.1"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
 dependencies = [
  "cfg-if",
  "crunchy",
+ "zerocopy",
 ]
 
 [[package]]
@@ -806,14 +819,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 dependencies = [
  "ahash",
+ "allocator-api2",
  "serde",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hermit-abi"
-version = "0.3.9"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
 [[package]]
 name = "hex"
@@ -823,28 +849,29 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "hstr"
-version = "0.2.10"
+version = "3.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96274be293b8877e61974a607105d09c84caebe9620b47774aa8a6b942042dd4"
+checksum = "0c43c0a9e8fbdb3bb9dc8eee85e1e2ac81605418b4c83b6b7413cbf14d56ca5c"
 dependencies = [
- "hashbrown",
+ "hashbrown 0.14.5",
  "new_debug_unreachable",
  "once_cell",
- "phf",
  "rustc-hash",
+ "serde",
  "triomphe",
 ]
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.60"
+version = "0.1.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
+ "log",
  "wasm-bindgen",
  "windows-core",
 ]
@@ -858,21 +885,113 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e93fcd3157766c0c8da2f8cff6ce651a31f0810eaa1c51ec363ef790bbb5fb99"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02845b3647bb045f1100ecd6480ff52f34c35f82d9880e029d329c21d1054899"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
 [[package]]
 name = "idna"
-version = "0.5.0"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "icu_normalizer",
+ "icu_properties",
 ]
 
 [[package]]
 name = "if_chain"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb56e1aa765b4b4f3aadfab769793b7087bb03a4ea4920644a6d238e2df5b9ed"
+checksum = "cd62e6b5e86ea8eeeb8db1de02880a6abc01a397b2ebb64b5d74ac255318f5cb"
 
 [[package]]
 name = "indent_write"
@@ -882,13 +1001,14 @@ checksum = "0cfe9645a18782869361d9c8732246be7b410ad4e919d3609ebabdac00ba12c3"
 
 [[package]]
 name = "indexmap"
-version = "2.2.6"
+version = "2.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"
 dependencies = [
  "equivalent",
- "hashbrown",
+ "hashbrown 0.16.1",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -902,24 +1022,23 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.39.0"
+version = "1.44.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "810ae6042d48e2c9e9215043563a58a80b877bc863228a74cf10c49d4620a6f5"
+checksum = "b5c943d4415edd8153251b6f197de5eb1640e56d84e8d9159bea190421c73698"
 dependencies = [
  "console",
- "lazy_static",
- "linked-hash-map",
+ "once_cell",
  "serde",
  "similar",
 ]
 
 [[package]]
 name = "is-macro"
-version = "0.3.5"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59a85abdc13717906baccb5a1e435556ce0df215f242892f721dff62bf25288f"
+checksum = "1d57a3e447e24c22647738e4607f1df1e0ec6f72e16182c4cd199f647cdfb0e4"
 dependencies = [
- "Inflector",
+ "heck",
  "proc-macro2",
  "quote",
  "syn",
@@ -927,20 +1046,20 @@ dependencies = [
 
 [[package]]
 name = "is-terminal"
-version = "0.4.12"
+version = "0.4.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
+checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
 dependencies = [
  "hermit-abi",
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.0"
+version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
 [[package]]
 name = "itertools"
@@ -962,16 +1081,17 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.11"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "jobserver"
-version = "0.1.31"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
 dependencies = [
+ "getrandom",
  "libc",
 ]
 
@@ -983,33 +1103,34 @@ checksum = "72167d68f5fce3b8655487b8038691a3c9984ee769590f93f2a631f4ad64e4f5"
 
 [[package]]
 name = "js-source-scopes"
-version = "0.5.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adfdc25288ccb82b33c3aa3f14587fd920b825690f3c4f8c5385b1d8998e9a40"
+checksum = "632e077b0fb37f6476d2fa0e15ee97afcfc2359a1a68b1990d4fa9f82324e3f0"
 dependencies = [
  "indexmap",
  "sourcemap",
  "swc_common",
  "swc_ecma_parser",
  "swc_ecma_visit",
- "thiserror",
+ "thiserror 2.0.17",
  "tracing",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.69"
+version = "0.3.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
 dependencies = [
+ "once_cell",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "lazy_static"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "leb128"
@@ -1019,51 +1140,44 @@ checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.177"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
 
 [[package]]
-name = "linked-hash-map"
-version = "0.5.6"
+name = "linux-raw-sys"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
 
 [[package]]
-name = "linux-raw-sys"
-version = "0.4.14"
+name = "litemap"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
 name = "lock_api"
-version = "0.4.12"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
 dependencies = [
- "autocfg",
  "scopeguard",
 ]
 
-[[package]]
-name = "lockfree-object-pool"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9374ef4228402d4b7e403e5838cb880d9ee663314b0a900d5a6aabf0c213552e"
-
 [[package]]
 name = "log"
-version = "0.4.21"
+version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
 name = "matchers"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
 dependencies = [
- "regex-automata 0.1.10",
+ "regex-automata",
 ]
 
 [[package]]
@@ -1074,24 +1188,24 @@ checksum = "4facc753ae494aeb6e3c22f839b158aebd4f9270f55cd3c79906c45476c47ab4"
 
 [[package]]
 name = "memchr"
-version = "2.7.2"
+version = "2.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
 [[package]]
 name = "memmap2"
-version = "0.9.4"
+version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe751422e4a8caa417e13c3ea66452215d7d63e19e604f4980461212f3ae1322"
+checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "minidump"
-version = "0.21.2"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d385b740c6b991e6eff48f26e2c6978c9e9e9e2e935f4967bcdf4c2d1d18828"
+checksum = "ebc7268c0afe5aa2fd6fde310e6cda158f0b3581f317c5a5c7d170861f9b90a6"
 dependencies = [
  "debugid",
  "encoding_rs",
@@ -1101,7 +1215,7 @@ dependencies = [
  "procfs-core",
  "range-map",
  "scroll 0.12.0",
- "thiserror",
+ "thiserror 1.0.69",
  "time",
  "tracing",
  "uuid",
@@ -1109,11 +1223,11 @@ dependencies = [
 
 [[package]]
 name = "minidump-common"
-version = "0.21.2"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c4d14bcca0fd3ed165a03000480aaa364c6860c34e900cb2dafdf3b95340e77"
+checksum = "0cde999358cca8fb9397c4298bb27c4a603c13ee6b3a646da514b20be582a21e"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.10.0",
  "debugid",
  "num-derive",
  "num-traits",
@@ -1124,9 +1238,9 @@ dependencies = [
 
 [[package]]
 name = "minidump-processor"
-version = "0.21.2"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7869a9256743611832cdf02d01ee5e2d67055a47727b21a01d47a79839876ca4"
+checksum = "41ab4c99352eb8bcc861eb06ceae910fc1d0a8395acc9ffd961fc230c9c12ca0"
 dependencies = [
  "async-trait",
  "breakpad-symbols",
@@ -1138,16 +1252,16 @@ dependencies = [
  "scroll 0.12.0",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "yaxpeax-x86",
 ]
 
 [[package]]
 name = "minidump-unwind"
-version = "0.21.2"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f4fb17e3a2508326b9547166051a979d439d883bcd1058b48a2d1181a0b37cf"
+checksum = "3b2bc4d6066050b350c5dddf066a25bfd6c9f20b8919dc66501d831524ab4dd4"
 dependencies = [
  "async-trait",
  "breakpad-symbols",
@@ -1159,7 +1273,7 @@ dependencies = [
 
 [[package]]
 name = "minidump_stackwalk"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "async-trait",
  "clap",
@@ -1167,7 +1281,7 @@ dependencies = [
  "minidump-processor",
  "minidump-unwind",
  "symbolic",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tracing",
  "tracing-subscriber",
@@ -1182,11 +1296,12 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.7.3"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87dfd01fe195c66b572b37921ad8803d010623c0aca821bea2302239d155cdae"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
 dependencies = [
- "adler",
+ "adler2",
+ "simd-adler32",
 ]
 
 [[package]]
@@ -1207,7 +1322,7 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4c25a3bb7d880e8eceab4822f3141ad0700d20f025991c1f03bd3d00219a5fc"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
@@ -1241,19 +1356,18 @@ dependencies = [
 
 [[package]]
 name = "nu-ansi-term"
-version = "0.46.0"
+version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "overload",
- "winapi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "num-bigint"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c165a9ab64cf766f73521c0dd2cfdff64f488b8f0b3e621face3462d3db536d7"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
 dependencies = [
  "num-integer",
  "num-traits",
@@ -1297,16 +1411,16 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.35.0"
+version = "0.32.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8ec7ab813848ba4522158d5517a6093db1ded27575b070f4177b8d12b41db5e"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "object_debug"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "clap",
  "symbolic",
@@ -1314,33 +1428,33 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.19.0"
+version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
-name = "oorandom"
-version = "11.1.3"
+name = "once_cell_polyfill"
+version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
-name = "outref"
-version = "0.1.0"
+name = "oorandom"
+version = "11.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f222829ae9293e33a9f5e9f440c6760a3d450a64affe1846486b140db81c1f4"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
 [[package]]
-name = "overload"
-version = "0.1.1"
+name = "outref"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
 
 [[package]]
 name = "parking_lot"
-version = "0.12.3"
+version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
 dependencies = [
  "lock_api",
  "parking_lot_core",
@@ -1348,15 +1462,15 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.10"
+version = "0.9.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
  "cfg-if",
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-targets 0.52.5",
+ "windows-link",
 ]
 
 [[package]]
@@ -1381,43 +1495,43 @@ dependencies = [
  "maybe-owned",
  "pdb",
  "range-collections",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "percent-encoding"
-version = "2.3.1"
+version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
 name = "phf"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
 dependencies = [
  "phf_macros",
- "phf_shared 0.11.2",
+ "phf_shared",
 ]
 
 [[package]]
 name = "phf_generator"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
 dependencies = [
- "phf_shared 0.11.2",
- "rand",
+ "phf_shared",
+ "rand 0.8.5",
 ]
 
 [[package]]
 name = "phf_macros"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3444646e286606587e49f3bcf1679b8cef1dc2c5ecc29ddacaffc305180d464b"
+checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
 dependencies = [
  "phf_generator",
- "phf_shared 0.11.2",
+ "phf_shared",
  "proc-macro2",
  "quote",
  "syn",
@@ -1425,27 +1539,18 @@ dependencies = [
 
 [[package]]
 name = "phf_shared"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
-dependencies = [
- "siphasher",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
 dependencies = [
- "siphasher",
+ "siphasher 1.0.1",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.14"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
 [[package]]
 name = "pin-utils"
@@ -1455,9 +1560,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "pkg-config"
-version = "0.3.30"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 
 [[package]]
 name = "plain"
@@ -1467,9 +1572,9 @@ checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
 
 [[package]]
 name = "plotters"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a15b6eccb8484002195a3e44fe65a4ce8e93a625797a063735536fd59cb01cf3"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
 dependencies = [
  "num-traits",
  "plotters-backend",
@@ -1480,25 +1585,43 @@ dependencies = [
 
 [[package]]
 name = "plotters-backend"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "414cec62c6634ae900ea1c56128dfe87cf63e7caece0852ec76aba307cebadb7"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
 
 [[package]]
 name = "plotters-svg"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81b30686a7d9c3e010b84284bdd26a29f2138574f52f5eb6f794fc0ad924e705"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
 dependencies = [
  "plotters-backend",
 ]
 
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
+
 [[package]]
 name = "powerfmt"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
 [[package]]
 name = "precomputed-hash"
 version = "0.1.1"
@@ -1507,51 +1630,86 @@ checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.85"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22244ce15aa966053a896d1accb3a6e68469b97c7f33f284b99f0d576879fc23"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "procfs-core"
-version = "0.16.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d3554923a69f4ce04c4a754260c338f505ce22642d3830e049a399fc2059a29"
+checksum = "239df02d8349b06fc07398a3a1697b06418223b1c7725085e801e7c0fc6a12ec"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.10.0",
  "hex",
 ]
 
 [[package]]
 name = "proguard"
-version = "5.4.1"
+version = "5.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b88dddb086b00f5539a95d2c7a2373358fd8bfadb7b1297cc29e0196403a1b98"
+checksum = "260b8aaeeb4bc5175bb90a599f51d74a560f19de428c2d058c67eac92b5085d3"
 dependencies = [
- "lazy_static",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
  "uuid",
+ "watto",
 ]
 
 [[package]]
-name = "psm"
-version = "0.1.21"
+name = "proptest"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5787f7cda34e3033a72192c018bc5883100330f362ef279a8cbccfce8bb4e874"
+checksum = "bee689443a2bd0a16ab0348b52ee43e3b2d1b1f931c8aa5c9f8de4c86fbe8c40"
 dependencies = [
+ "bit-set",
+ "bit-vec",
+ "bitflags 2.10.0",
+ "num-traits",
+ "rand 0.9.2",
+ "rand_chacha",
+ "rand_xorshift",
+ "regex-syntax",
+ "rusty-fork",
+ "tempfile",
+ "unarray",
+]
+
+[[package]]
+name = "psm"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d11f2fedc3b7dafdc2851bc52f277377c5473d378859be234bc7ebb593144d01"
+dependencies = [
+ "ar_archive_writer",
  "cc",
 ]
 
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
 dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
 [[package]]
 name = "radium"
 version = "0.7.0"
@@ -1564,7 +1722,27 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha",
+ "rand_core 0.9.3",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
@@ -1573,6 +1751,24 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
+dependencies = [
+ "rand_core 0.9.3",
+]
+
 [[package]]
 name = "range-collections"
 version = "0.2.4"
@@ -1595,9 +1791,9 @@ dependencies = [
 
 [[package]]
 name = "rayon"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
 dependencies = [
  "either",
  "rayon-core",
@@ -1605,9 +1801,9 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.12.1"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
 dependencies = [
  "crossbeam-deque",
  "crossbeam-utils",
@@ -1615,96 +1811,90 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.1"
+version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "469052894dcb553421e483e4209ee581a45100d31b4018de03e5a7ad86374a7e"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
 name = "regex"
-version = "1.10.4"
+version = "1.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.6",
- "regex-syntax 0.8.3",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
-dependencies = [
- "regex-syntax 0.6.29",
+ "regex-automata",
+ "regex-syntax",
 ]
 
 [[package]]
 name = "regex-automata"
-version = "0.4.6"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.8.3",
+ "regex-syntax",
 ]
 
 [[package]]
 name = "regex-syntax"
-version = "0.6.29"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.24"
+version = "0.1.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
+checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"
 
 [[package]]
 name = "rustc-hash"
-version = "1.1.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
-name = "rustc_version"
-version = "0.2.3"
+name = "rustix"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
+checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
 dependencies = [
- "semver 0.9.0",
+ "bitflags 2.10.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "rustix"
-version = "0.38.34"
+name = "rustversion"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "rusty-fork"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2"
 dependencies = [
- "bitflags 2.5.0",
- "errno",
- "libc",
- "linux-raw-sys",
- "windows-sys 0.52.0",
+ "fnv",
+ "quick-error",
+ "tempfile",
+ "wait-timeout",
 ]
 
 [[package]]
 name = "ryu"
-version = "1.0.18"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 
 [[package]]
 name = "same-file"
@@ -1744,9 +1934,9 @@ dependencies = [
 
 [[package]]
 name = "scroll_derive"
-version = "0.12.0"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f81c2fde025af7e69b1d1420531c8a8811ca898919db177141a85313b1cb932"
+checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1755,39 +1945,40 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "0.9.0"
+version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
-dependencies = [
- "semver-parser",
-]
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
 
 [[package]]
-name = "semver"
-version = "1.0.23"
+name = "seq-macro"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
+checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
 
 [[package]]
-name = "semver-parser"
-version = "0.7.0"
+name = "serde"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
 
 [[package]]
-name = "serde"
-version = "1.0.203"
+name = "serde_core"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.203"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1796,20 +1987,22 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.117"
+version = "1.0.145"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"
+checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
 dependencies = [
  "itoa",
+ "memchr",
  "ryu",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "sha1_smol"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae1a47186c03a32177042e55dbc5fd5aee900b8e0069a8d70fba96a9375cd012"
+checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d"
 
 [[package]]
 name = "sharded-slab"
@@ -1820,11 +2013,17 @@ dependencies = [
  "lazy_static",
 ]
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "signal-hook"
-version = "0.3.17"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
+checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
 dependencies = [
  "libc",
  "signal-hook-registry",
@@ -1832,9 +2031,9 @@ dependencies = [
 
 [[package]]
 name = "signal-hook-mio"
-version = "0.2.3"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29ad2e15f37ec9a6cc544097b78a1ec90001e9f71b81338ca39f430adaca99af"
+checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
 dependencies = [
  "libc",
  "mio",
@@ -1843,22 +2042,13 @@ dependencies = [
 
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.2"
+version = "1.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
+checksum = "7664a098b8e616bdfcc2dc0e9ac44eb231eedf41db4e9fe95d8d32ec728dedad"
 dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "simd-abstraction"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cadb29c57caadc51ff8346233b5cec1d240b68ce55cf1afc764818791876987"
-dependencies = [
- "outref",
-]
-
 [[package]]
 name = "simd-adler32"
 version = "0.3.7"
@@ -1867,9 +2057,9 @@ checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
 
 [[package]]
 name = "similar"
-version = "2.5.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
 dependencies = [
  "bstr",
  "unicode-segmentation",
@@ -1877,9 +2067,9 @@ dependencies = [
 
 [[package]]
 name = "similar-asserts"
-version = "1.5.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e041bb827d1bfca18f213411d51b665309f1afb37a04a5d1464530e13779fc0f"
+checksum = "b5b441962c817e33508847a22bd82f03a30cff43642dc2fae8b050566121eb9a"
 dependencies = [
  "console",
  "similar",
@@ -1891,20 +2081,23 @@ version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
 
+[[package]]
+name = "siphasher"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
+
 [[package]]
 name = "slab"
-version = "0.4.9"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
-dependencies = [
- "autocfg",
-]
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "smallvec"
-version = "1.13.2"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "smart-default"
@@ -1930,9 +2123,9 @@ dependencies = [
 
 [[package]]
 name = "sourcemap"
-version = "8.0.1"
+version = "9.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "208d40b9e8cad9f93613778ea295ed8f3c2b1824217c6cfc7219d3f6f45b96d4"
+checksum = "e22afbcb92ce02d23815b9795523c005cb9d3c214f8b7a66318541c240ea7935"
 dependencies = [
  "base64-simd",
  "bitvec",
@@ -1940,7 +2133,6 @@ dependencies = [
  "debugid",
  "if_chain",
  "rustc-hash",
- "rustc_version",
  "serde",
  "serde_json",
  "unicode-id-start",
@@ -1949,7 +2141,7 @@ dependencies = [
 
 [[package]]
 name = "sourcemapcache_debug"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "anyhow",
  "clap",
@@ -1957,23 +2149,33 @@ dependencies = [
  "tracing-subscriber",
 ]
 
+[[package]]
+name = "srcsrv"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85cd3e3828fb4dd5ba0e7091777edb6c3db3cd2d6fc10547b29b40f6949a29be"
+dependencies = [
+ "memchr",
+ "thiserror 2.0.17",
+]
+
 [[package]]
 name = "stable_deref_trait"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "stacker"
-version = "0.1.15"
+version = "0.1.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c886bd4480155fd3ef527d45e9ac8dd7118a898a46530b7b94c3e21866259fce"
+checksum = "e1f8b29fb42aafcea4edeeb6b2f2d7ecd0d969c48b4cf0d2e64aafc471dd6e59"
 dependencies = [
  "cc",
  "cfg-if",
  "libc",
  "psm",
- "winapi",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1984,25 +2186,23 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "string_cache"
-version = "0.8.7"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f91138e76242f575eb1d3b38b4f1362f10d3a43f47d182a5b359af488a02293b"
+checksum = "bf776ba3fa74f83bf4b63c3dcbbf82173db2632ed8452cb2d891d33f459de70f"
 dependencies = [
  "new_debug_unreachable",
- "once_cell",
  "parking_lot",
- "phf_shared 0.10.0",
+ "phf_shared",
  "precomputed-hash",
  "serde",
 ]
 
 [[package]]
 name = "string_enum"
-version = "0.4.4"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05e383308aebc257e7d7920224fa055c632478d92744eca77f99be8fa1545b90"
+checksum = "ae36a4951ca7bd1cfd991c241584a9824a70f6aff1e7d4f693fb3f2465e4030e"
 dependencies = [
- "proc-macro2",
  "quote",
  "swc_macros_common",
  "syn",
@@ -2016,25 +2216,25 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "swc_atoms"
-version = "0.6.7"
+version = "9.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb6567e4e67485b3e7662b486f1565bdae54bd5b9d6b16b2ba1a9babb1e42125"
+checksum = "d4ccbe2ecad10ad7432100f878a107b1d972a8aee83ca53184d00c23a078bb8a"
 dependencies = [
  "hstr",
  "once_cell",
- "rustc-hash",
  "serde",
 ]
 
 [[package]]
 name = "swc_common"
-version = "0.33.26"
+version = "17.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2f9706038906e66f3919028f9f7a37f3ed552f1b85578e93f4468742e2da438"
+checksum = "259b675d633a26d24efe3802a9d88858c918e6e8f062d3222d3aa02d56a2cf4c"
 dependencies = [
+ "anyhow",
  "ast_node",
  "better_scoped_tls",
- "cfg-if",
+ "bytes-str",
  "either",
  "from_variant",
  "new_debug_unreachable",
@@ -2042,7 +2242,7 @@ dependencies = [
  "once_cell",
  "rustc-hash",
  "serde",
- "siphasher",
+ "siphasher 0.3.11",
  "swc_atoms",
  "swc_eq_ignore_macros",
  "swc_visit",
@@ -2053,49 +2253,51 @@ dependencies = [
 
 [[package]]
 name = "swc_ecma_ast"
-version = "0.113.6"
+version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ae3fb68e165bb093ea05fe68dfbc5d378c8b41515a5160f733d7b45bfb9d96e"
+checksum = "a573a0c72850dec8d4d8085f152d5778af35a2520c3093b242d2d1d50776da7c"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.10.0",
  "is-macro",
  "num-bigint",
+ "once_cell",
  "phf",
- "scoped-tls",
+ "rustc-hash",
  "string_enum",
  "swc_atoms",
  "swc_common",
+ "swc_visit",
  "unicode-id-start",
 ]
 
 [[package]]
 name = "swc_ecma_parser"
-version = "0.144.1"
+version = "27.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0499e69683ae5d67a20ff0279b94bc90f29df7922a46331b54d5dd367bf89570"
+checksum = "7f1a51af1a92cd4904c073b293e491bbc0918400a45d58227b34c961dd6f52d7"
 dependencies = [
+ "bitflags 2.10.0",
  "either",
- "new_debug_unreachable",
  "num-bigint",
- "num-traits",
  "phf",
+ "rustc-hash",
+ "seq-macro",
  "serde",
- "smallvec",
  "smartstring",
  "stacker",
  "swc_atoms",
  "swc_common",
  "swc_ecma_ast",
  "tracing",
- "typed-arena",
 ]
 
 [[package]]
 name = "swc_ecma_visit"
-version = "0.99.1"
+version = "18.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28a6ce28ad8e591f8d627f1f9cb26b25e5d83052a9bc1b674d95fc28040cfa98"
+checksum = "a9611a72a4008d62608547a394e5d72a5245413104db096d95a52368a8cc1d63"
 dependencies = [
+ "new_debug_unreachable",
  "num-bigint",
  "swc_atoms",
  "swc_common",
@@ -2106,9 +2308,9 @@ dependencies = [
 
 [[package]]
 name = "swc_eq_ignore_macros"
-version = "0.1.3"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "695a1d8b461033d32429b5befbf0ad4d7a2c4d6ba9cd5ba4e0645c615839e8e4"
+checksum = "c16ce73424a6316e95e09065ba6a207eba7765496fed113702278b7711d4b632"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2117,9 +2319,9 @@ dependencies = [
 
 [[package]]
 name = "swc_macros_common"
-version = "0.3.11"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91745f3561057493d2da768437c427c0e979dff7396507ae02f16c981c4a8466"
+checksum = "aae1efbaa74943dc5ad2a2fb16cbd78b77d7e4d63188f3c5b4df2b4dcd2faaae"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2128,30 +2330,17 @@ dependencies = [
 
 [[package]]
 name = "swc_visit"
-version = "0.5.14"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "043d11fe683dcb934583ead49405c0896a5af5face522e4682c16971ef7871b9"
+checksum = "62fb71484b486c185e34d2172f0eabe7f4722742aad700f426a494bb2de232a2"
 dependencies = [
  "either",
- "swc_visit_macros",
-]
-
-[[package]]
-name = "swc_visit_macros"
-version = "0.5.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ae9ef18ff8daffa999f729db056d2821cd2f790f3a11e46422d19f46bb193e7"
-dependencies = [
- "Inflector",
- "proc-macro2",
- "quote",
- "swc_macros_common",
- "syn",
+ "new_debug_unreachable",
 ]
 
 [[package]]
 name = "symbolic"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "symbolic-cfi",
  "symbolic-common",
@@ -2166,7 +2355,7 @@ dependencies = [
 
 [[package]]
 name = "symbolic-cabi"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "anyhow",
  "proguard",
@@ -2177,19 +2366,19 @@ dependencies = [
 
 [[package]]
 name = "symbolic-cfi"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "insta",
  "similar-asserts",
  "symbolic-common",
  "symbolic-debuginfo",
  "symbolic-testutils",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "symbolic-common"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "debugid",
  "memmap2",
@@ -2203,16 +2392,15 @@ dependencies = [
 
 [[package]]
 name = "symbolic-debuginfo"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "criterion",
  "debugid",
- "dmsort",
  "elementtree",
  "elsa",
  "fallible-iterator 0.3.0",
  "flate2",
- "gimli 0.30.0",
+ "gimli",
  "goblin",
  "insta",
  "lazy_static",
@@ -2221,17 +2409,19 @@ dependencies = [
  "once_cell",
  "parking_lot",
  "pdb-addr2line",
+ "proptest",
  "regex",
  "scroll 0.12.0",
  "serde",
  "serde_json",
  "similar-asserts",
  "smallvec",
+ "srcsrv",
  "symbolic-common",
  "symbolic-ppdb",
  "symbolic-testutils",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.69",
  "wasmparser",
  "zip",
  "zstd",
@@ -2239,7 +2429,7 @@ dependencies = [
 
 [[package]]
 name = "symbolic-demangle"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "cc",
  "cpp_demangle",
@@ -2251,7 +2441,7 @@ dependencies = [
 
 [[package]]
 name = "symbolic-il2cpp"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "indexmap",
  "serde_json",
@@ -2261,7 +2451,7 @@ dependencies = [
 
 [[package]]
 name = "symbolic-ppdb"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "flate2",
  "indexmap",
@@ -2270,28 +2460,28 @@ dependencies = [
  "symbolic-common",
  "symbolic-debuginfo",
  "symbolic-testutils",
- "thiserror",
+ "thiserror 1.0.69",
  "uuid",
  "watto",
 ]
 
 [[package]]
 name = "symbolic-sourcemapcache"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "itertools 0.13.0",
  "js-source-scopes",
  "sourcemap",
  "symbolic-common",
  "symbolic-testutils",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "watto",
 ]
 
 [[package]]
 name = "symbolic-symcache"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "criterion",
  "indexmap",
@@ -2300,18 +2490,18 @@ dependencies = [
  "symbolic-debuginfo",
  "symbolic-il2cpp",
  "symbolic-testutils",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "watto",
 ]
 
 [[package]]
 name = "symbolic-testutils"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 
 [[package]]
 name = "symbolic-unreal"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "anylog",
  "bytes",
@@ -2325,13 +2515,13 @@ dependencies = [
  "serde",
  "similar-asserts",
  "symbolic-testutils",
- "thiserror",
+ "thiserror 1.0.69",
  "time",
 ]
 
 [[package]]
 name = "symcache_debug"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "anyhow",
  "clap",
@@ -2340,15 +2530,26 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.66"
+version = "2.0.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c42f3f41a2de00b01c0aaad383c5a45241efc8b2d1eda5661812fda5f3cdcff5"
+checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "tap"
 version = "1.0.1"
@@ -2357,30 +2558,51 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "tempfile"
-version = "3.10.1"
+version = "3.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
 dependencies = [
- "cfg-if",
  "fastrand",
+ "getrandom",
+ "once_cell",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
 ]
 
 [[package]]
 name = "thiserror"
-version = "1.0.61"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.17",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.61"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2389,19 +2611,18 @@ dependencies = [
 
 [[package]]
 name = "thread_local"
-version = "1.1.8"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
 dependencies = [
  "cfg-if",
- "once_cell",
 ]
 
 [[package]]
 name = "time"
-version = "0.3.36"
+version = "0.3.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
+checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
 dependencies = [
  "deranged",
  "itoa",
@@ -2414,61 +2635,55 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.2"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
+checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
 
 [[package]]
 name = "time-macros"
-version = "0.2.18"
+version = "0.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
+checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
 dependencies = [
  "num-conv",
  "time-core",
 ]
 
 [[package]]
-name = "tinytemplate"
-version = "1.2.1"
+name = "tinystr"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
 dependencies = [
- "serde",
- "serde_json",
+ "displaydoc",
+ "zerovec",
 ]
 
 [[package]]
-name = "tinyvec"
-version = "1.6.0"
+name = "tinytemplate"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
 dependencies = [
- "tinyvec_macros",
+ "serde",
+ "serde_json",
 ]
 
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
-
 [[package]]
 name = "tokio"
-version = "1.38.0"
+version = "1.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a"
+checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408"
 dependencies = [
- "backtrace",
  "pin-project-lite",
  "tokio-macros",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "2.3.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f5ae998a069d4b5aba8ee9dad856af7d520c3699e6159b185c2acd48155d39a"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2477,9 +2692,9 @@ dependencies = [
 
 [[package]]
 name = "tracing"
-version = "0.1.40"
+version = "0.1.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
+checksum = "2d15d90a0b5c19378952d479dc858407149d7bb45a14de0142f6c534b16fc647"
 dependencies = [
  "log",
  "pin-project-lite",
@@ -2489,9 +2704,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.27"
+version = "0.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2500,9 +2715,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-core"
-version = "0.1.32"
+version = "0.1.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
+checksum = "7a04e24fab5c89c6a36eb8558c9656f30d81de51dfa4d3b45f26b21d61fa0a6c"
 dependencies = [
  "once_cell",
  "valuable",
@@ -2521,14 +2736,14 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.18"
+version = "0.3.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
+checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
 dependencies = [
  "matchers",
  "nu-ansi-term",
  "once_cell",
- "regex",
+ "regex-automata",
  "sharded-slab",
  "smallvec",
  "thread_local",
@@ -2539,62 +2754,47 @@ dependencies = [
 
 [[package]]
 name = "triomphe"
-version = "0.1.12"
+version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b2cb4fbb9995eeb36ac86fadf24031ccd58f99d6b4b2d7b911db70bddb80d90"
+checksum = "dd69c5aa8f924c7519d6372789a74eac5b94fb0f8fcf0d4a97eb0bfc3e785f39"
 dependencies = [
  "serde",
  "stable_deref_trait",
 ]
 
 [[package]]
-name = "typed-arena"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a"
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.15"
+name = "unarray"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
 [[package]]
 name = "unicode-id-start"
-version = "1.0.4"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02aebfa694eccbbbffdd92922c7de136b9fe764396d2f10e21bce1681477cfc1"
+checksum = "81b79ad29b5e19de4260020f8919b443b2ef0277d242ce532ec7b7a2cc8b6007"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
-
-[[package]]
-name = "unicode-normalization"
-version = "0.1.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
-dependencies = [
- "tinyvec",
-]
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.11.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.12"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68f5e5f3158ecfd4b8ff6fe086db7c8467a2dfdac97fe420f2b7c4aa97af66d6"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
 
 [[package]]
 name = "unreal_engine_crash"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 dependencies = [
  "clap",
  "symbolic",
@@ -2602,41 +2802,65 @@ dependencies = [
 
 [[package]]
 name = "url"
-version = "2.5.0"
+version = "2.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
+checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
 dependencies = [
  "form_urlencoded",
  "idna",
  "percent-encoding",
+ "serde",
 ]
 
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "utf8parse"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.8.0"
+version = "1.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
+checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
 dependencies = [
+ "js-sys",
  "sha1_smol",
+ "wasm-bindgen",
 ]
 
 [[package]]
 name = "valuable"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "vsimd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64"
+
+[[package]]
+name = "wait-timeout"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
+dependencies = [
+ "libc",
+]
 
 [[package]]
 name = "walkdir"
@@ -2650,40 +2874,37 @@ dependencies = [
 
 [[package]]
 name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
-name = "wasm-bindgen"
-version = "0.2.92"
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
 dependencies = [
- "cfg-if",
- "wasm-bindgen-macro",
+ "wit-bindgen",
 ]
 
 [[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.92"
+name = "wasm-bindgen"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
 dependencies = [
- "bumpalo",
- "log",
+ "cfg-if",
  "once_cell",
- "proc-macro2",
- "quote",
- "syn",
+ "rustversion",
+ "wasm-bindgen-macro",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -2691,34 +2912,37 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
 dependencies = [
+ "bumpalo",
  "proc-macro2",
  "quote",
  "syn",
- "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
+dependencies = [
+ "unicode-ident",
+]
 
 [[package]]
 name = "wasmparser"
-version = "0.209.1"
+version = "0.214.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07035cc9a9b41e62d3bb3a3815a66ab87c993c06fe1cf6b2a3f2a18499d937db"
+checksum = "5309c1090e3e84dad0d382f42064e9933fdaedb87e468cc239f0eabea73ddcb6"
 dependencies = [
  "ahash",
- "bitflags 2.5.0",
- "hashbrown",
+ "bitflags 2.10.0",
+ "hashbrown 0.14.5",
  "indexmap",
- "semver 1.0.23",
+ "semver",
  "serde",
 ]
 
@@ -2729,14 +2953,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6746b5315e417144282a047ebb82260d45c92d09bf653fa9ec975e3809be942b"
 dependencies = [
  "leb128",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "web-sys"
-version = "0.3.69"
+version = "0.3.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
+checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -2760,11 +2984,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.8"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2775,11 +2999,61 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows-core"
-version = "0.52.0"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
- "windows-targets 0.52.5",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
 ]
 
 [[package]]
@@ -2793,11 +3067,20 @@ dependencies = [
 
 [[package]]
 name = "windows-sys"
-version = "0.52.0"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
 dependencies = [
- "windows-targets 0.52.5",
+ "windows-link",
 ]
 
 [[package]]
@@ -2817,18 +3100,18 @@ dependencies = [
 
 [[package]]
 name = "windows-targets"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.5",
- "windows_aarch64_msvc 0.52.5",
- "windows_i686_gnu 0.52.5",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
  "windows_i686_gnullvm",
- "windows_i686_msvc 0.52.5",
- "windows_x86_64_gnu 0.52.5",
- "windows_x86_64_gnullvm 0.52.5",
- "windows_x86_64_msvc 0.52.5",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]
 
 [[package]]
@@ -2839,9 +3122,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -2851,9 +3134,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -2863,15 +3146,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
 [[package]]
 name = "windows_i686_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -2881,9 +3164,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -2893,9 +3176,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -2905,9 +3188,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -2917,9 +3200,21 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.5"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
 
 [[package]]
 name = "wyz"
@@ -2955,20 +3250,97 @@ dependencies = [
  "yaxpeax-arch",
 ]
 
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
 [[package]]
 name = "zerocopy"
-version = "0.7.34"
+version = "0.8.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae87e3fcd617500e5d106f0380cf7b77f3c6092aae37191433159dda23cfb087"
+checksum = "4ea879c944afe8a2b25fef16bb4ba234f47c694565e97383b36f3a878219065c"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.34"
+version = "0.8.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf955aa904d6040f70dc8e9384444cb1030aed272ba3cb09bbc4ab9e7c1f34f5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15e934569e47891f7d9411f1a451d947a60e000ab3bd24fbb970f000387d1b3b"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2977,9 +3349,9 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "2.1.1"
+version = "2.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dd56a4d5921bc2f99947ac5b3abe5f510b1be7376fdc5e9fce4a23c6a93e87c"
+checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
 dependencies = [
  "arbitrary",
  "crc32fast",
@@ -2988,47 +3360,45 @@ dependencies = [
  "flate2",
  "indexmap",
  "memchr",
- "thiserror",
+ "thiserror 2.0.17",
  "zopfli",
 ]
 
 [[package]]
 name = "zopfli"
-version = "0.8.1"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5019f391bac5cf252e93bbcc53d039ffd62c7bfb7c150414d61369afe57e946"
+checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249"
 dependencies = [
  "bumpalo",
  "crc32fast",
- "lockfree-object-pool",
  "log",
- "once_cell",
  "simd-adler32",
 ]
 
 [[package]]
 name = "zstd"
-version = "0.13.1"
+version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d789b1514203a1120ad2429eae43a7bd32b90976a7bb8a05f7ec02fa88cc23a"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
 dependencies = [
  "zstd-safe",
 ]
 
 [[package]]
 name = "zstd-safe"
-version = "7.1.0"
+version = "7.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cd99b45c6bc03a018c8b8a86025678c87e55526064e38f9df301989dce7ec0a"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
 dependencies = [
  "zstd-sys",
 ]
 
 [[package]]
 name = "zstd-sys"
-version = "2.0.10+zstd.1.5.6"
+version = "2.0.16+zstd.1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c253a4914af5bafc8fa8c86ee400827e83cf6ec01195ec1f1ed8441bf00d65aa"
+checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748"
 dependencies = [
  "cc",
  "pkg-config",
diff --git a/Cargo.toml b/Cargo.toml
index f60f1aee2..1f236df51 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,6 +2,10 @@
 resolver = "2"
 members = ["symbolic*", "examples/*"]
 
+[workspace.package]
+edition = "2021"
+rust-version = "1.82"
+
 [workspace.dependencies]
 anyhow = "1.0.32"
 anylog = "0.6.4"
@@ -13,28 +17,28 @@ clap = "4.4.5"
 cpp_demangle = "0.4.1"
 criterion = { version = "0.5.1", features = ["html_reports"] }
 debugid = "0.8.0"
-dmsort = "1.0.2"
 elementtree = "1.2.3"
 elsa = "1.8.0"
 fallible-iterator = "0.3.0"
 flate2 = { version = "1.0.25", default-features = false, features = [
-    "rust_backend",
+  "rust_backend",
 ] }
-gimli = { version = "0.30.0", default-features = false, features = [
-    "read",
-    "std",
-    "fallible-iterator",
+gimli = { version = "0.32.3", default-features = false, features = [
+  "read",
+  "std",
+  "fallible-iterator",
 ] }
 goblin = { version = "0.8.0", default-features = false }
 indexmap = "2.0.0"
 insta = { version = "1.28.0", features = ["yaml"] }
 itertools = "0.13.0"
-js-source-scopes = "0.5.0"
+# Point to master branch which has the swc fix for serde compatibility (>= 0.7.0)
+js-source-scopes = "0.7.0"
 lazy_static = "1.4.0"
 memmap2 = "0.9.0"
-minidump = "0.21.0"
-minidump-processor = "0.21.0"
-minidump-unwind = "0.21.0"
+minidump = "0.22.0"
+minidump-processor = "0.22.0"
+minidump-unwind = "0.22.0"
 msvc-demangler = "0.10.0"
 nom = "7.1.3"
 nom-supreme = "0.8.0"
@@ -42,15 +46,17 @@ once_cell = "1.17.1"
 parking_lot = "0.12.1"
 pdb-addr2line = "0.10.4"
 proguard = { version = "5.4.0", features = ["uuid"] }
+proptest = "1.6.0"
 regex = "1.7.1"
 rustc-demangle = "0.1.21"
 # keep this in sync with whatever version `goblin` uses
 scroll = "0.12.0"
+# Unpinned - js-source-scopes master branch is now compatible with latest serde
 serde = { version = "1.0.171", features = ["derive"] }
 serde_json = "1.0.102"
 similar-asserts = "1.4.2"
 smallvec = "1.10.0"
-sourcemap = "8.0.1"
+sourcemap = "9.2.2"
 stable_deref_trait = "1.2.0"
 tempfile = "3.4.0"
 thiserror = "1.0.39"
@@ -60,7 +66,7 @@ tracing = "0.1.34"
 tracing-subscriber = "0.3.11"
 uuid = "1.3.0"
 walkdir = "2.3.1"
-wasmparser = "0.209.1"
+wasmparser = "0.214.0"
 watto = { version = "0.1.0", features = ["writer", "strings"] }
 # We are currently pinning a known good version prior to https://github.com/zip-rs/zip2/issues/189
 # (dd) NOTE: previously pinned to 2.1.1, however this version is now yanked from crates.io
diff --git a/Makefile b/Makefile
index 2294c8159..a27ce2a71 100644
--- a/Makefile
+++ b/Makefile
@@ -18,7 +18,7 @@ build:
 .PHONY: build
 
 sdist: .venv/bin/python
-	cd py && ../.venv/bin/python setup.py sdist --format=zip
+	cd py && ../.venv/bin/python setup.py sdist
 .PHONY: sdist
 
 wheel: .venv/bin/python
diff --git a/README.md b/README.md
index 4ffc8c6db..e494115bf 100644
--- a/README.md
+++ b/README.md
@@ -102,7 +102,7 @@ make lint
 ```
 
 Most likely, new functionality also needs to be added to the Python package. This first requires to
-expose new functions in the C ABI. For this, refer to the [Symbolic C-ABI readme](sentry-cabi/README.md).
+expose new functions in the C ABI. For this, refer to the [Symbolic C-ABI readme](symbolic-cabi/README.md).
 
 We highly recommend to develop and test the python package in a **virtual environment**. Once the
 ABI has been updated and tested, ensure the virtualenv is active and install the package, which
@@ -158,6 +158,13 @@ To run these examples, use the `run` script. For example:
 ./run minidump_stackwalk mini.dmp /path/to/files
 ```
 
+## Supported Rust Versions
+
+Symbolic tries to not break MSRV compatibility but makes no guarantees about the Rust version.
+Although you can expect Rust version compatibility of **at least 6 months**.
+
+The current MSRV is 1.82.
+
 ## License
 
 Symbolic is licensed under the MIT license. It uses some Apache2 licensed code
diff --git a/examples/addr2line/Cargo.toml b/examples/addr2line/Cargo.toml
index 4750f45ce..ca631c047 100644
--- a/examples/addr2line/Cargo.toml
+++ b/examples/addr2line/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "addr2line"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 authors = ["Jan Michael Auer <mail@jauer.org>"]
 edition = "2021"
 publish = false
@@ -10,4 +10,4 @@ publish = false
 [dependencies]
 anyhow = { workspace = true }
 clap = { workspace = true }
-symbolic = { version = "12.9.2-dd", path = "../../symbolic", features = ["demangle"] }
+symbolic = { version = "12.17.0-dd", path = "../../symbolic", features = ["demangle"] }
diff --git a/examples/debuginfo_debug/Cargo.toml b/examples/debuginfo_debug/Cargo.toml
index 77ae79e8c..91757d887 100644
--- a/examples/debuginfo_debug/Cargo.toml
+++ b/examples/debuginfo_debug/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "debuginfo_debug"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 authors = ["Markus Stange <mstange.moz@gmail.com>"]
 edition = "2021"
 publish = false
@@ -10,6 +10,6 @@ publish = false
 [dependencies]
 anyhow = { workspace = true }
 clap = { workspace = true }
-symbolic = { version = "12.9.2-dd", path = "../../symbolic", features = [
+symbolic = { version = "12.17.0-dd", path = "../../symbolic", features = [
     "demangle",
 ] }
diff --git a/examples/dump_cfi/Cargo.toml b/examples/dump_cfi/Cargo.toml
index 2a3bef004..c8ccd9a9b 100644
--- a/examples/dump_cfi/Cargo.toml
+++ b/examples/dump_cfi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "dump_cfi"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 authors = ["Jan Michael Auer <mail@jauer.org>"]
 edition = "2021"
 publish = false
@@ -10,4 +10,4 @@ publish = false
 [dependencies]
 anyhow = { workspace = true }
 clap = { workspace = true }
-symbolic = { version = "12.9.2-dd", path = "../../symbolic", features = ["cfi"] }
+symbolic = { version = "12.17.0-dd", path = "../../symbolic", features = ["cfi"] }
diff --git a/examples/dump_sources/Cargo.toml b/examples/dump_sources/Cargo.toml
index 06e9574ee..810f1c50d 100644
--- a/examples/dump_sources/Cargo.toml
+++ b/examples/dump_sources/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "dump_sources"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 authors = ["Jan Michael Auer <mail@jauer.org>"]
 edition = "2021"
 publish = false
@@ -9,4 +9,4 @@ publish = false
 
 [dependencies]
 clap = { workspace = true }
-symbolic = { version = "12.9.2-dd", path = "../../symbolic" }
+symbolic = { version = "12.17.0-dd", path = "../../symbolic" }
diff --git a/examples/minidump_stackwalk/Cargo.toml b/examples/minidump_stackwalk/Cargo.toml
index ea3cb973b..83ada8dae 100644
--- a/examples/minidump_stackwalk/Cargo.toml
+++ b/examples/minidump_stackwalk/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "minidump_stackwalk"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 authors = ["Jan Michael Auer <mail@jauer.org>"]
 edition = "2021"
 publish = false
@@ -13,7 +13,7 @@ clap = { workspace = true }
 minidump = { workspace = true }
 minidump-processor = { workspace = true }
 minidump-unwind = { workspace = true }
-symbolic = { version = "12.9.2-dd", path = "../../symbolic", features = [
+symbolic = { version = "12.17.0-dd", path = "../../symbolic", features = [
     "symcache",
     "demangle",
     "cfi",
diff --git a/examples/minidump_stackwalk/src/main.rs b/examples/minidump_stackwalk/src/main.rs
index fd6a53029..f9cb1c98f 100644
--- a/examples/minidump_stackwalk/src/main.rs
+++ b/examples/minidump_stackwalk/src/main.rs
@@ -41,42 +41,7 @@ struct ObjectDatabase {
     by_code_id: HashMap<CodeId, Vec<ObjectMetadata>>,
 }
 
-/// Metadata about an object in the filesystem.
-#[derive(Debug, Clone)]
-struct ObjectMetadata {
-    /// The object's path.
-    path: PathBuf,
-    /// The object's index in its archive.
-    index_in_archive: usize,
-    /// Whether the object has unwind info.
-    has_unwind_info: bool,
-    /// Whether the object has symbol info.
-    has_symbol_info: bool,
-}
-
-/// A SymbolProvider that recursively searches a given path for symbol files.
-struct LocalSymbolProvider<'a> {
-    object_files: ObjectDatabase,
-    cfi_files: Mutex<CfiFiles>,
-    symcaches: Mutex<SymCaches<'a>>,
-    use_cfi: bool,
-    symbolicate: bool,
-}
-
-impl<'a> LocalSymbolProvider<'a> {
-    /// Constructs a `LocalSymbolProvider` that will look for symbol files under the given path.
-    fn new<P: AsRef<Path>>(path: Option<P>, use_cfi: bool, symbolicate: bool) -> Self {
-        Self {
-            object_files: path.map_or(Default::default(), |path| {
-                Self::create_object_database(path)
-            }),
-            cfi_files: Mutex::new(BTreeMap::default()),
-            symcaches: Mutex::new(SymCaches::default()),
-            use_cfi,
-            symbolicate,
-        }
-    }
-
+impl ObjectDatabase {
     /// Accumulates a database of objects found under the given path.
     ///
     /// The objects are saved in a map from `DebugId`s to vectors of
@@ -86,11 +51,11 @@ impl<'a> LocalSymbolProvider<'a> {
     /// * whether the object has unwind info
     /// * whether the object has symbol info
     #[tracing::instrument(skip_all, fields(path = ?path.as_ref()))]
-    fn create_object_database(path: impl AsRef<Path>) -> ObjectDatabase {
+    fn from_path(path: impl AsRef<Path>) -> ObjectDatabase {
         let mut object_db = ObjectDatabase::default();
         for entry in WalkDir::new(path).into_iter().filter_map(Result::ok) {
             // Folders will be recursed into automatically
-            if !entry.metadata().map_or(false, |md| md.is_file()) {
+            if !entry.metadata().is_ok_and(|md| md.is_file()) {
                 continue;
             }
 
@@ -149,6 +114,58 @@ impl<'a> LocalSymbolProvider<'a> {
         object_db
     }
 
+    /// Merges another [`ObjectDatabase`] into the current one.
+    fn merge(mut self, other: Self) -> Self {
+        let Self {
+            by_debug_id,
+            by_code_id,
+        } = other;
+
+        self.by_debug_id.extend(by_debug_id);
+        self.by_code_id.extend(by_code_id);
+
+        self
+    }
+}
+
+/// Metadata about an object in the filesystem.
+#[derive(Debug, Clone)]
+struct ObjectMetadata {
+    /// The object's path.
+    path: PathBuf,
+    /// The object's index in its archive.
+    index_in_archive: usize,
+    /// Whether the object has unwind info.
+    has_unwind_info: bool,
+    /// Whether the object has symbol info.
+    has_symbol_info: bool,
+}
+
+/// A SymbolProvider that recursively searches a given path for symbol files.
+struct LocalSymbolProvider<'a> {
+    object_files: ObjectDatabase,
+    cfi_files: Mutex<CfiFiles>,
+    symcaches: Mutex<SymCaches<'a>>,
+    use_cfi: bool,
+    symbolicate: bool,
+}
+
+impl<'a> LocalSymbolProvider<'a> {
+    /// Constructs a `LocalSymbolProvider` that will look for symbol files under the given path.
+    fn new<P: AsRef<Path>>(path: &[P], use_cfi: bool, symbolicate: bool) -> Self {
+        Self {
+            object_files: path
+                .iter()
+                .map(ObjectDatabase::from_path)
+                .reduce(ObjectDatabase::merge)
+                .unwrap_or_default(),
+            cfi_files: Mutex::new(BTreeMap::default()),
+            symcaches: Mutex::new(SymCaches::default()),
+            use_cfi,
+            symbolicate,
+        }
+    }
+
     /// Fetches the [`ObjectMetadata`] for the given id, using the [`DebugId`] or the [`CodeId`]
     /// as fallback.
     fn object_info(&self, id: LookupId) -> Option<&Vec<ObjectMetadata>> {
@@ -172,6 +189,8 @@ impl<'a> LocalSymbolProvider<'a> {
     /// Objects which have unwind information are then tried in order.
     #[tracing::instrument(skip_all, fields(id = ?id))]
     fn load_cfi(&self, id: LookupId) -> Result<SymbolFile, SymbolError> {
+        tracing::info!("loading cficache");
+
         let object_list = self.object_info(id).ok_or(SymbolError::NotFound)?;
         let mut found = None;
         for object_meta in object_list.iter().filter(|object| object.has_unwind_info) {
@@ -218,6 +237,8 @@ impl<'a> LocalSymbolProvider<'a> {
         &self,
         id: LookupId,
     ) -> Result<SelfCell<ByteView<'a>, SymCache<'a>>, SymbolError> {
+        tracing::info!("loading symcache");
+
         let object_list = self.object_info(id).ok_or(SymbolError::NotFound)?;
         let mut found = None;
         for object_meta in object_list.iter().filter(|object| object.has_symbol_info) {
@@ -262,7 +283,7 @@ impl<'a> LocalSymbolProvider<'a> {
 }
 
 #[async_trait]
-impl<'a> minidump_unwind::SymbolProvider for LocalSymbolProvider<'a> {
+impl minidump_unwind::SymbolProvider for LocalSymbolProvider<'_> {
     #[tracing::instrument(
         skip(self, module, frame),
         fields(module.id, frame.instruction = frame.get_instruction())
@@ -272,22 +293,44 @@ impl<'a> minidump_unwind::SymbolProvider for LocalSymbolProvider<'a> {
         module: &(dyn Module + Sync),
         frame: &mut (dyn FrameSymbolizer + Send),
     ) -> Result<(), FillSymbolError> {
-        if !self.symbolicate {
-            return Err(FillSymbolError {});
-        }
-
         let id = (
             module.code_identifier(),
             module.debug_identifier().unwrap_or_default(),
         );
         tracing::Span::current().record("module.id", tracing::field::debug(&id));
 
+        let instruction = frame.get_instruction();
+
+        let mut cfi = self.cfi_files.lock().unwrap();
+        if let Ok(symbol_file) = cfi
+            .entry(id.clone())
+            .or_insert_with(|| self.load_cfi(id.clone()))
+        {
+            // Validity check that the instruction provided points to a valid stack frame.
+            //
+            // This is similar to the lookup check below for symcache symbol info.
+            // If we can already filter out instructions which are definitely not valid,
+            // we can help the stack walker not hallucinate frames which do not exist.
+            //
+            // Returning here without providing any symbol info, will cause the stack walker
+            // to skip the frame. An error will hallucinate a frame.
+            let cfi_stack_info = symbol_file
+                .cfi_stack_info
+                .get(instruction - module.base_address());
+            if cfi_stack_info.is_none() {
+                return Ok(());
+            }
+        };
+
+        if !self.symbolicate {
+            return Err(FillSymbolError {});
+        }
+
         let mut symcaches = self.symcaches.lock().unwrap();
 
-        let symcache = symcaches.entry(id.clone()).or_insert_with(|| {
-            tracing::info!("loading symcache for the first time");
-            self.load_symbol_info(id)
-        });
+        let symcache = symcaches
+            .entry(id.clone())
+            .or_insert_with(|| self.load_symbol_info(id));
 
         let symcache = match symcache {
             Ok(symcache) => symcache,
@@ -299,12 +342,22 @@ impl<'a> minidump_unwind::SymbolProvider for LocalSymbolProvider<'a> {
 
         tracing::info!("symcache successfully loaded");
 
-        let instruction = frame.get_instruction();
-        let source_location = symcache
+        let Some(source_location) = symcache
             .get()
             .lookup(instruction - module.base_address())
             .last()
-            .ok_or(FillSymbolError {})?;
+        else {
+            // The instruction definitely belongs to this module, but we cannot
+            // find the instruction. In which case this is most likely not a real
+            // frame.
+            //
+            // The Minidump stack-walker skips all frames without a name and continues
+            // the search, but it assumes there is a correct frame if the lookup
+            // fails. To not hallucinate frames, we return `Ok(())` here (a frame without a name).
+            //
+            // See also above, the cfi validity check.
+            return Ok(());
+        };
 
         frame.set_function(
             source_location.function().name(),
@@ -341,10 +394,7 @@ impl<'a> minidump_unwind::SymbolProvider for LocalSymbolProvider<'a> {
 
         let mut cfi = self.cfi_files.lock().unwrap();
 
-        let symbol_file = cfi.entry(id.clone()).or_insert_with(|| {
-            tracing::info!("loading cficache for the first time");
-            self.load_cfi(id)
-        });
+        let symbol_file = cfi.entry(id.clone()).or_insert_with(|| self.load_cfi(id));
 
         match symbol_file {
             Ok(file) => {
@@ -486,10 +536,7 @@ impl fmt::Display for Report<'_> {
         };
 
         for (ti, thread) in self.process_state.threads.iter().enumerate() {
-            let crashed = self
-                .process_state
-                .requesting_thread
-                .map_or(false, |i| ti == i);
+            let crashed = self.process_state.requesting_thread == Some(ti);
 
             if self.options.crashed_only && !crashed {
                 continue;
@@ -613,10 +660,13 @@ impl fmt::Display for Report<'_> {
 
 async fn execute(matches: &ArgMatches) -> Result<(), Error> {
     let minidump_path = matches.get_one::<PathBuf>("minidump_file_path").unwrap();
-    let symbols_path = matches.get_one::<PathBuf>("debug_symbols_path");
+    let symbols_path = matches
+        .get_many::<PathBuf>("debug_symbols_path")
+        .map(|s| s.collect::<Vec<_>>())
+        .unwrap_or_default();
 
     let symbol_provider = LocalSymbolProvider::new(
-        symbols_path,
+        &symbols_path,
         *matches.get_one("cfi").unwrap(),
         *matches.get_one("symbolize").unwrap(),
     );
@@ -658,6 +708,7 @@ async fn main() {
         )
         .arg(
             Arg::new("debug_symbols_path")
+                .action(ArgAction::Append)
                 .value_name("symbols")
                 .value_parser(value_parser!(PathBuf))
                 .help("Path to a folder containing debug symbols"),
diff --git a/examples/object_debug/Cargo.toml b/examples/object_debug/Cargo.toml
index f7f9cdc47..b069d1e55 100644
--- a/examples/object_debug/Cargo.toml
+++ b/examples/object_debug/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "object_debug"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 authors = ["Jan Michael Auer <mail@jauer.org>"]
 edition = "2021"
 publish = false
@@ -9,4 +9,4 @@ publish = false
 
 [dependencies]
 clap = { workspace = true }
-symbolic = { version = "12.9.2-dd", path = "../../symbolic" }
+symbolic = { version = "12.17.0-dd", path = "../../symbolic" }
diff --git a/examples/sourcemapcache_debug/Cargo.toml b/examples/sourcemapcache_debug/Cargo.toml
index fa5c07c15..0fe1c0125 100644
--- a/examples/sourcemapcache_debug/Cargo.toml
+++ b/examples/sourcemapcache_debug/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sourcemapcache_debug"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 authors = ["Sentry <hello@sentry.io>"]
 edition = "2021"
 publish = false
@@ -8,7 +8,7 @@ publish = false
 [dependencies]
 anyhow = { workspace = true }
 clap = { workspace = true }
-symbolic = { version = "12.9.2-dd", path = "../../symbolic", features = [
+symbolic = { version = "12.17.0-dd", path = "../../symbolic", features = [
     "sourcemapcache",
 ] }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
diff --git a/examples/symcache_debug/Cargo.toml b/examples/symcache_debug/Cargo.toml
index 8b5daf610..7547e51d3 100644
--- a/examples/symcache_debug/Cargo.toml
+++ b/examples/symcache_debug/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symcache_debug"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 authors = ["Jan Michael Auer <mail@jauer.org>"]
 edition = "2021"
 publish = false
@@ -10,7 +10,7 @@ publish = false
 [dependencies]
 anyhow = { workspace = true }
 clap = { workspace = true }
-symbolic = { version = "12.9.2-dd", path = "../../symbolic", features = [
+symbolic = { version = "12.17.0-dd", path = "../../symbolic", features = [
     "symcache",
     "demangle",
     "il2cpp",
diff --git a/examples/symcache_debug/src/main.rs b/examples/symcache_debug/src/main.rs
index 47e1e2703..fcce8a913 100644
--- a/examples/symcache_debug/src/main.rs
+++ b/examples/symcache_debug/src/main.rs
@@ -2,7 +2,6 @@ use std::fs::File;
 use std::io::{Cursor, Write};
 use std::path::PathBuf;
 use std::str::FromStr;
-use std::u64;
 
 use anyhow::{anyhow, Context, Result};
 use clap::builder::ValueParser;
diff --git a/examples/unreal_engine_crash/Cargo.toml b/examples/unreal_engine_crash/Cargo.toml
index bccfc1aca..022a99776 100644
--- a/examples/unreal_engine_crash/Cargo.toml
+++ b/examples/unreal_engine_crash/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "unreal_engine_crash"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 authors = ["Jan Michael Auer <mail@jauer.org>"]
 edition = "2021"
 publish = false
@@ -9,6 +9,6 @@ publish = false
 
 [dependencies]
 clap = { workspace = true }
-symbolic = { version = "12.9.2-dd", path = "../../symbolic", features = [
+symbolic = { version = "12.17.0-dd", path = "../../symbolic", features = [
     "unreal",
 ] }
diff --git a/examples/unreal_engine_crash/src/main.rs b/examples/unreal_engine_crash/src/main.rs
index ac3a1e4ea..5b46b58f6 100644
--- a/examples/unreal_engine_crash/src/main.rs
+++ b/examples/unreal_engine_crash/src/main.rs
@@ -1,20 +1,12 @@
 use std::fs::File;
-use std::io::Read;
+use std::io::{BufWriter, Read, Write};
 use std::{cmp, path::PathBuf};
 
 use clap::{value_parser, Arg, ArgMatches, Command};
 
 use symbolic::unreal::{Unreal4Crash, Unreal4FileType};
 
-fn execute(matches: &ArgMatches) -> Result<(), Box<dyn std::error::Error>> {
-    let crash_file_path = matches.get_one::<PathBuf>("crash_file_path").unwrap();
-
-    let mut file = File::open(crash_file_path)?;
-    let mut file_content = Vec::new();
-    file.read_to_end(&mut file_content)?;
-
-    let ue4_crash = Unreal4Crash::parse(&file_content)?;
-
+fn print_debug(ue4_crash: Unreal4Crash) -> Result<(), Box<dyn std::error::Error>> {
     match ue4_crash.file_by_type(Unreal4FileType::Minidump) {
         Some(m) => println!("Minidump size: {} bytes.", m.data().len()),
         None => println!("No minidump found in the Unreal Crash provided."),
@@ -40,7 +32,26 @@ fn execute(matches: &ArgMatches) -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-fn main() {
+fn extract(
+    ue4_crash: Unreal4Crash,
+    matches: &ArgMatches,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let filename = matches.get_one::<String>("filename").unwrap();
+
+    let Some(file) = ue4_crash.files().find(|file| file.name() == filename) else {
+        return Err(format!("No file named '{filename}' in crash report").into());
+    };
+
+    let mut output: Box<dyn Write> = match matches.get_one::<PathBuf>("output_path") {
+        Some(output) => Box::new(BufWriter::new(File::create(output)?)),
+        None => Box::new(std::io::stdout()),
+    };
+    output.write_all(file.data())?;
+
+    Ok(())
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     let matches = Command::new("unreal-engine-crash")
         .about("Unpack an Unreal Engine crash report")
         .arg(
@@ -50,10 +61,38 @@ fn main() {
                 .value_parser(value_parser!(PathBuf))
                 .help("Path to the crash file"),
         )
+        .subcommand(
+            Command::new("extract")
+                .about("extract a single file from the crash file")
+                .arg(
+                    Arg::new("output_path")
+                        .short('o')
+                        .long("output")
+                        .value_parser(value_parser!(PathBuf))
+                        .help(
+                            "Path to write the file to, if missing contents are written to stdout",
+                        ),
+                )
+                .arg(
+                    Arg::new("filename")
+                        .required(true)
+                        .value_name("filename")
+                        .help("filename to extract"),
+                ),
+        )
         .get_matches();
 
-    match execute(&matches) {
-        Ok(()) => (),
-        Err(e) => println!("Error: {e}"),
+    let crash = {
+        let crash_file_path = matches.get_one::<PathBuf>("crash_file_path").unwrap();
+        let mut file = File::open(crash_file_path)?;
+        let mut file_content = Vec::new();
+        file.read_to_end(&mut file_content)?;
+        Unreal4Crash::parse(&file_content)?
     };
+
+    match matches.subcommand() {
+        Some(("extract", matches)) => extract(crash, matches),
+        None => print_debug(crash),
+        _ => unreachable!(),
+    }
 }
diff --git a/py/manylinux.sh b/py/manylinux.sh
index 028149410..67231f613 100755
--- a/py/manylinux.sh
+++ b/py/manylinux.sh
@@ -4,22 +4,22 @@ set -e
 # Install dependencies needed by our wheel
 yum -y -q -e 0 install gcc libffi-devel
 
-# upgrade wheel
-/opt/python/cp36-cp36m/bin/pip install --upgrade wheel
+# Upgrade wheel
+/opt/python/cp311-cp311/bin/pip install --upgrade wheel
 
 # Install Rust
 curl https://sh.rustup.rs -sSf | sh -s -- -y
 export PATH=~/.cargo/bin:$PATH
 
-cat > ~/.cargo/config <<EOF
+cat >~/.cargo/config <<EOF
 [net]
 git-fetch-with-cli = true
 EOF
 
-/opt/python/cp36-cp36m/bin/python setup.py bdist_wheel
+/opt/python/cp311-cp311/bin/python setup.py bdist_wheel
 
 # Audit wheels
 for wheel in dist/*-linux_*.whl; do
-  auditwheel repair "$wheel" -w dist/
-  rm "$wheel"
+	auditwheel repair "$wheel" -w dist/
+	rm "$wheel"
 done
diff --git a/py/setup.py b/py/setup.py
index 8109d923a..6f655ce18 100644
--- a/py/setup.py
+++ b/py/setup.py
@@ -107,10 +107,16 @@ def find_dylib():
     long_description=readme,
     include_package_data=True,
     package_data={"symbolic": ["py.typed", "_lowlevel.pyi"]},
+    long_description_content_type="text/markdown",
     zip_safe=False,
     platforms="any",
     install_requires=["milksnake>=0.1.2"],
-    setup_requires=["milksnake>=0.1.2"],
+    # Specify transitive dependencies manually that are required for the build because
+    # they are not resolved properly since upgrading to python 3.11 in manylinux.
+    # milksnake -> cffi -> pycparser
+    # milksnake specifies cffi>=1.6.0 as dependency while cffi does not specify a
+    # minimum version for pycparser
+    setup_requires=["milksnake>=0.1.2", "cffi>=1.6.0", "pycparser"],
     python_requires=">=3.8",
     milksnake_tasks=[build_native],
     cmdclass={"sdist": CustomSDist},
diff --git a/py/symbolic/sourcemap.py b/py/symbolic/sourcemap.py
index 291ce6bdb..ea02e7e0d 100644
--- a/py/symbolic/sourcemap.py
+++ b/py/symbolic/sourcemap.py
@@ -172,6 +172,11 @@ def get_source_name(self, idx: int) -> str | None:
         name = self._methodcall(lib.symbolic_sourcemapview_get_source_name, idx)
         return decode_str(name, free=True) or None
 
+    def get_source_contents(self, idx: int) -> str | None:
+        """Returns the contents of the source at the given index."""
+        name = self._methodcall(lib.symbolic_sourcemapview_get_source_contents, idx)
+        return decode_str(name, free=True) or None
+
     def iter_sources(self) -> Generator[tuple[int, str | None], None, None]:
         """Iterates over the sources in the file."""
         for src_id in range(self.source_count):
diff --git a/symbolic-cabi/Cargo.toml b/symbolic-cabi/Cargo.toml
index 9b0e360e4..a2c767bd5 100644
--- a/symbolic-cabi/Cargo.toml
+++ b/symbolic-cabi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-cabi"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 authors = [
     "Armin Ronacher <armin.ronacher@active-4.com>",
@@ -23,7 +23,7 @@ crate-type = ["cdylib", "lib"]
 proguard = { workspace = true, features = ["uuid"] }
 anyhow = "1.0.32"
 sourcemap = { workspace = true }
-symbolic = { version = "12.9.2-dd", path = "../symbolic", features = [
+symbolic = { version = "12.17.0-dd", path = "../symbolic", features = [
     "cfi",
     "debuginfo",
     "demangle",
diff --git a/symbolic-cabi/include/symbolic.h b/symbolic-cabi/include/symbolic.h
index 96b3a49f3..b0081a179 100644
--- a/symbolic-cabi/include/symbolic.h
+++ b/symbolic-cabi/include/symbolic.h
@@ -657,6 +657,11 @@ struct SymbolicTokenMatch *symbolic_sourcemapview_lookup_token_with_function_nam
 const struct SymbolicSourceView *symbolic_sourcemapview_get_sourceview(const struct SymbolicSourceMapView *source_map,
                                                                        uint32_t index);
 
+/**
+ * Return the number of sources.
+ */
+uint32_t symbolic_sourcemapview_get_source_count(const struct SymbolicSourceMapView *source_map);
+
 /**
  * Return the source name for an index.
  */
@@ -664,9 +669,10 @@ struct SymbolicStr symbolic_sourcemapview_get_source_name(const struct SymbolicS
                                                           uint32_t index);
 
 /**
- * Return the number of sources.
+ * Return the source contents for an index.
  */
-uint32_t symbolic_sourcemapview_get_source_count(const struct SymbolicSourceMapView *source_map);
+struct SymbolicStr symbolic_sourcemapview_get_source_contents(const struct SymbolicSourceMapView *source_map,
+                                                          uint32_t index);
 
 /**
  * Returns a specific token.
diff --git a/symbolic-cabi/src/core.rs b/symbolic-cabi/src/core.rs
index 6e0d8e922..893ba3fba 100644
--- a/symbolic-cabi/src/core.rs
+++ b/symbolic-cabi/src/core.rs
@@ -87,7 +87,7 @@ impl From<String> for SymbolicStr {
     }
 }
 
-impl<'a> From<&'a str> for SymbolicStr {
+impl From<&str> for SymbolicStr {
     fn from(string: &str) -> SymbolicStr {
         SymbolicStr::new(string)
     }
@@ -351,11 +351,7 @@ pub unsafe extern "C" fn symbolic_str_free(string: *mut SymbolicStr) {
 /// Returns true if the uuid is nil.
 #[no_mangle]
 pub unsafe extern "C" fn symbolic_uuid_is_nil(uuid: *const SymbolicUuid) -> bool {
-    if let Ok(uuid) = Uuid::from_slice(&(*uuid).data[..]) {
-        uuid == Uuid::nil()
-    } else {
-        false
-    }
+    Uuid::from_bytes((*uuid).data) == Uuid::nil()
 }
 
 /// Formats the UUID into a string.
@@ -364,6 +360,6 @@ pub unsafe extern "C" fn symbolic_uuid_is_nil(uuid: *const SymbolicUuid) -> bool
 /// `symbolic_cstr_free`.
 #[no_mangle]
 pub unsafe extern "C" fn symbolic_uuid_to_str(uuid: *const SymbolicUuid) -> SymbolicStr {
-    let uuid = Uuid::from_slice(&(*uuid).data[..]).unwrap_or_default();
+    let uuid = Uuid::from_bytes((*uuid).data);
     SymbolicStr::from_string(uuid.hyphenated().to_string())
 }
diff --git a/symbolic-cabi/src/proguard.rs b/symbolic-cabi/src/proguard.rs
index 02798312e..92c91caec 100644
--- a/symbolic-cabi/src/proguard.rs
+++ b/symbolic-cabi/src/proguard.rs
@@ -33,7 +33,7 @@ struct Inner<'a> {
 impl<'slf, 'a: 'slf> AsSelf<'slf> for Inner<'a> {
     type Ref = Inner<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
diff --git a/symbolic-cabi/src/sourcemap.rs b/symbolic-cabi/src/sourcemap.rs
index 2c0fa80fe..7df2bc09c 100644
--- a/symbolic-cabi/src/sourcemap.rs
+++ b/symbolic-cabi/src/sourcemap.rs
@@ -227,6 +227,15 @@ ffi_fn! {
     }
 }
 
+ffi_fn! {
+    /// Return the number of sources.
+    unsafe fn symbolic_sourcemapview_get_source_count(
+        source_map: *const SymbolicSourceMapView
+    ) -> Result<u32> {
+        Ok(SymbolicSourceMapView::as_rust(source_map).inner.get_source_count())
+    }
+}
+
 ffi_fn! {
     /// Return the source name for an index.
     unsafe fn symbolic_sourcemapview_get_source_name(
@@ -240,11 +249,14 @@ ffi_fn! {
 }
 
 ffi_fn! {
-    /// Return the number of sources.
-    unsafe fn symbolic_sourcemapview_get_source_count(
-        source_map: *const SymbolicSourceMapView
-    ) -> Result<u32> {
-        Ok(SymbolicSourceMapView::as_rust(source_map).inner.get_source_count())
+    /// Return the source contents for an index.
+    unsafe fn symbolic_sourcemapview_get_source_contents(
+        source_map: *const SymbolicSourceMapView,
+        index: u32
+    ) -> Result<SymbolicStr> {
+        let view = SymbolicSourceMapView::as_rust(source_map);
+        let contents_opt = view.inner.get_source_contents(index);
+        Ok(contents_opt.unwrap_or("").into())
     }
 }
 
@@ -254,7 +266,7 @@ ffi_fn! {
         source_map: *const SymbolicSourceMapView,
         index: u32
     ) -> Result<*mut SymbolicTokenMatch> {
-        let token = SymbolicSourceMapView::as_rust(source_map).inner.get_token(index);
+        let token = SymbolicSourceMapView::as_rust(source_map).inner.get_token(index as usize);
         Ok(token.map(make_token_match).unwrap_or_else(ptr::null_mut))
     }
 }
diff --git a/symbolic-cfi/Cargo.toml b/symbolic-cfi/Cargo.toml
index f9ca5534a..2dc90ce6a 100644
--- a/symbolic-cfi/Cargo.toml
+++ b/symbolic-cfi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-cfi"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 authors = [
     "Armin Ronacher <armin.ronacher@active-4.com>",
@@ -12,11 +12,12 @@ repository = "https://github.com/getsentry/symbolic"
 description = """
 A library to process call frame information
 """
-edition = "2021"
+edition.workspace = true
+rust-version.workspace = true
 
 [dependencies]
-symbolic-common = { version = "12.9.2-dd", path = "../symbolic-common" }
-symbolic-debuginfo = { version = "12.9.2-dd", path = "../symbolic-debuginfo" }
+symbolic-common = { version = "12.17.0-dd", path = "../symbolic-common" }
+symbolic-debuginfo = { version = "12.17.0-dd", path = "../symbolic-debuginfo" }
 thiserror = { workspace = true }
 
 [dev-dependencies]
diff --git a/symbolic-cfi/src/lib.rs b/symbolic-cfi/src/lib.rs
index 9f710e41a..939700e17 100644
--- a/symbolic-cfi/src/lib.rs
+++ b/symbolic-cfi/src/lib.rs
@@ -717,6 +717,15 @@ impl<W: Write> AsciiCfiWriter<W> {
         R: Reader + Eq,
         U: UnwindSection<R>,
     {
+        // We have seen FDEs with an initial address of `u64::MAX` in user-provided
+        // DWARF files. Such FDEs will invariably fail to process because of either
+        // an address overflow error in `gimli` or an underflow in the `length`
+        // calculation below. Therefore, we skip them immediately so we don't abort
+        // the processing of the entire file.
+        if fde.initial_address() == u64::MAX {
+            return Ok(());
+        }
+
         // Retrieves the register that specifies the return address. We need to assign a special
         // format to this register for Breakpad.
         let ra = fde.cie().return_address_register();
@@ -785,7 +794,7 @@ impl<W: Write> AsciiCfiWriter<W> {
                 // row.
                 let mut ra_written = false;
                 for &(register, ref rule) in row.registers() {
-                    if !rule_cache.get(&register).map_or(false, |c| c == &rule) {
+                    if rule_cache.get(&register) != Some(&rule) {
                         rule_cache.insert(register, rule);
                         if register == ra {
                             ra_written = true;
@@ -894,7 +903,7 @@ impl<W: Write> AsciiCfiWriter<W> {
             // occur with a `code_start` close to the end of a function's code range, it seems
             // likely that these belong to the function epilog and code_size has a different meaning
             // in this case. Until this value is understood, skip these entries.
-            if frame.code_size > i32::max_value() as u32 {
+            if frame.code_size > i32::MAX as u32 {
                 continue;
             }
 
@@ -1189,7 +1198,7 @@ struct CfiCacheV1<'a> {
     byteview: ByteView<'a>,
 }
 
-impl<'a> CfiCacheV1<'a> {
+impl CfiCacheV1<'_> {
     pub fn raw(&self) -> &[u8] {
         &self.byteview
     }
@@ -1268,7 +1277,7 @@ fn write_preamble<W: Write>(mut writer: W, version: u32) -> Result<(), io::Error
 impl<'a> CfiCache<'a> {
     /// Load a symcache from a `ByteView`.
     pub fn from_bytes(byteview: ByteView<'a>) -> Result<Self, CfiError> {
-        if byteview.len() == 0 || byteview.starts_with(b"STACK") {
+        if byteview.is_empty() || byteview.starts_with(b"STACK") {
             let inner = CfiCacheInner::Unversioned(CfiCacheV1 { byteview });
             return Ok(CfiCache { inner });
         }
diff --git a/symbolic-cfi/tests/snapshots/test_cfi__cfi_elf.snap b/symbolic-cfi/tests/snapshots/test_cfi__cfi_elf.snap
index 35363db14..7e119c613 100644
--- a/symbolic-cfi/tests/snapshots/test_cfi__cfi_elf.snap
+++ b/symbolic-cfi/tests/snapshots/test_cfi__cfi_elf.snap
@@ -1,7 +1,5 @@
 ---
-created: "2019-07-05T18:52:40.332785Z"
-creator: insta@0.8.1
-source: minidump/tests/test_cfi.rs
+source: symbolic-cfi/tests/test_cfi.rs
 expression: cfi
 ---
 STACK CFI INIT 1dc0 2a .cfa: $rsp 8 +
@@ -1502,4 +1500,3 @@ STACK CFI 14c90 .cfa: $rsp 24 +
 STACK CFI 14c92 .cfa: $rsp 16 +
 STACK CFI 14c94 .cfa: $rsp 8 +
 STACK CFI INIT 14ca0 2 .cfa: $rsp 8 + .ra: .cfa -8 + ^
-
diff --git a/symbolic-cfi/tests/snapshots/test_cfi__cfi_macho.snap b/symbolic-cfi/tests/snapshots/test_cfi__cfi_macho.snap
index 1a247ca53..e8f2ea5e6 100644
--- a/symbolic-cfi/tests/snapshots/test_cfi__cfi_macho.snap
+++ b/symbolic-cfi/tests/snapshots/test_cfi__cfi_macho.snap
@@ -1,7 +1,6 @@
 ---
-source: symbolic-minidump/tests/test_cfi.rs
+source: symbolic-cfi/tests/test_cfi.rs
 expression: cfi
-
 ---
 STACK CFI INIT d20 1a .cfa: $rsp 8 + .ra: .cfa -8 + ^
 STACK CFI INIT d40 1a .cfa: $rsp 8 + .ra: .cfa -8 + ^
@@ -302,4 +301,3 @@ STACK CFI INIT db50 41 .cfa: $rsp 8 + .ra: .cfa -8 + ^
 STACK CFI db51 .cfa: $rsp 16 +
 STACK CFI INIT dba0 d0 .cfa: $rsp 320 + .ra: .cfa -8 + ^ $rbx: .cfa -16 + ^
 STACK CFI INIT dc70 34 .cfa: $rsp 16 + .ra: .cfa -8 + ^ $rbx: .cfa -16 + ^
-
diff --git a/symbolic-cfi/tests/snapshots/test_cfi__cfi_pdb_windows.snap b/symbolic-cfi/tests/snapshots/test_cfi__cfi_pdb_windows.snap
index 7f87ea4da..e768b5d69 100644
--- a/symbolic-cfi/tests/snapshots/test_cfi__cfi_pdb_windows.snap
+++ b/symbolic-cfi/tests/snapshots/test_cfi__cfi_pdb_windows.snap
@@ -1,7 +1,5 @@
 ---
-created: "2019-04-03T18:49:08.328347Z"
-creator: insta@0.7.4
-source: minidump/tests/test_cfi.rs
+source: symbolic-cfi/tests/test_cfi.rs
 expression: cfi
 ---
 STACK WIN 4 1000 114 11 0 8 0 0 0 1 $T0 .raSearch = $eip $T0 ^ = $esp $T0 4 + =
@@ -156,4 +154,3 @@ STACK WIN 4 358f 187 0 0 0 4 24 0 1 $T0 $ebp = $eip $T0 4 + ^ = $ebp $T0 ^ = $es
 STACK WIN 4 35b7 ef 0 0 0 8 24 0 1 $T0 $ebp = $eip $T0 4 + ^ = $ebp $T0 ^ = $esp $T0 8 + =  $20 $T0 40 - ^ =  $23 $T0 44 - ^ =
 STACK WIN 4 35b8 ed 0 0 0 c 24 0 1 $T0 $ebp = $eip $T0 4 + ^ = $ebp $T0 ^ = $esp $T0 8 + =  $20 $T0 40 - ^ =  $23 $T0 44 - ^ =  $24 $T0 48 - ^ =
 STACK WIN 4 371a c 0 0 0 0 0 0 1 $T0 .raSearch = $eip $T0 ^ = $esp $T0 4 + =
-
diff --git a/symbolic-cfi/tests/snapshots/test_cfi__cfi_pe_windows.snap b/symbolic-cfi/tests/snapshots/test_cfi__cfi_pe_windows.snap
index 3e4ad0296..99d98520c 100644
--- a/symbolic-cfi/tests/snapshots/test_cfi__cfi_pe_windows.snap
+++ b/symbolic-cfi/tests/snapshots/test_cfi__cfi_pe_windows.snap
@@ -1,6 +1,5 @@
 ---
 source: symbolic-cfi/tests/test_cfi.rs
-assertion_line: 105
 expression: cfi
 ---
 STACK CFI INIT 1010 55 .cfa: $rsp 80 + $rbx: .cfa 16 - ^ $rsi: .cfa 24 - ^ $rdi: .cfa 32 - ^ .ra: .cfa 8 - ^
@@ -44,4 +43,3 @@ STACK CFI INIT 1de8 1b9 .cfa: $rsp 48 + $rsi: .cfa 16 - ^ $rdi: .cfa 24 - ^ $r14
 STACK CFI INIT 2090 2 .cfa: $rsp 8 + .ra: .cfa 8 - ^
 STACK CFI INIT 20ac 1e .cfa: $rsp 48 + $rbp: .cfa 16 - ^ .ra: .cfa 8 - ^
 STACK CFI INIT 20ca 18 .cfa: $rsp 16 + $rbp: .cfa 16 - ^ .ra: .cfa 8 - ^
-
diff --git a/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_linux.snap b/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_linux.snap
index e05b652a7..e6a9ba137 100644
--- a/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_linux.snap
+++ b/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_linux.snap
@@ -1,7 +1,5 @@
 ---
-created: "2019-02-20T15:42:11.809248Z"
-creator: insta@0.6.3
-source: minidump/tests/test_cfi.rs
+source: symbolic-cfi/tests/test_cfi.rs
 expression: cfi
 ---
 STACK CFI INIT 1dc0 2a .cfa: $rsp 8 + .ra: .cfa -8 + ^
@@ -1502,4 +1500,3 @@ STACK CFI 14c90 .cfa: $rsp 24 +
 STACK CFI 14c92 .cfa: $rsp 16 +
 STACK CFI 14c94 .cfa: $rsp 8 +
 STACK CFI INIT 14ca0 2 .cfa: $rsp 8 + .ra: .cfa -8 + ^
-
diff --git a/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_macos.snap b/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_macos.snap
index 755f55fb4..d31e56fc5 100644
--- a/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_macos.snap
+++ b/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_macos.snap
@@ -1,7 +1,5 @@
 ---
-created: "2019-02-20T15:42:11.796554Z"
-creator: insta@0.6.3
-source: minidump/tests/test_cfi.rs
+source: symbolic-cfi/tests/test_cfi.rs
 expression: cfi
 ---
 STACK CFI INIT d20 1a .cfa: $rsp 8 + .ra: .cfa -8 + ^
@@ -217,4 +215,3 @@ STACK CFI INIT db30 a .cfa: $rsp 8 + .ra: .cfa -8 + ^
 STACK CFI INIT db40 a .cfa: $rsp 8 + .ra: .cfa -8 + ^
 STACK CFI INIT db50 41 .cfa: $rsp 8 + .ra: .cfa -8 + ^
 STACK CFI db51 .cfa: $rsp 16 +
-
diff --git a/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_windows.snap b/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_windows.snap
index f0e0e89ba..9059f5562 100644
--- a/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_windows.snap
+++ b/symbolic-cfi/tests/snapshots/test_cfi__cfi_sym_windows.snap
@@ -1,7 +1,5 @@
 ---
-created: "2019-02-20T15:42:11.796623Z"
-creator: insta@0.6.3
-source: minidump/tests/test_cfi.rs
+source: symbolic-cfi/tests/test_cfi.rs
 expression: cfi
 ---
 STACK WIN 4 1000 114 11 0 8 0 0 0 1 $T0 .raSearch = $eip $T0 ^ = $esp $T0 4 + =
@@ -158,4 +156,3 @@ STACK WIN 4 35b8 ed 0 0 0 c 24 0 1 $T0 $ebp = $eip $T0 4 + ^ = $ebp $T0 ^ = $esp
 STACK WIN 4 371a c 0 0 0 0 0 0 1 $T0 .raSearch = $eip $T0 ^ = $esp $T0 4 + =
 STACK WIN 0 2dc4 14 0 0 0 0 0 0 0 0
 STACK WIN 0 30fc 13 0 0 0 0 0 0 0 0
-
diff --git a/symbolic-common/Cargo.toml b/symbolic-common/Cargo.toml
index 5c6ded1d9..8a64ddd63 100644
--- a/symbolic-common/Cargo.toml
+++ b/symbolic-common/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-common"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 authors = [
     "Armin Ronacher <armin.ronacher@active-4.com>",
@@ -14,7 +14,8 @@ description = """
 Common types and utilities for symbolic, a library to symbolicate and process
 stack traces from native applications, minidumps or minified JavaScript.
 """
-edition = "2021"
+edition.workspace = true
+rust-version.workspace = true
 
 [package.metadata.docs.rs]
 all-features = true
diff --git a/symbolic-common/src/byteview.rs b/symbolic-common/src/byteview.rs
index f535a6111..b4f8af558 100644
--- a/symbolic-common/src/byteview.rs
+++ b/symbolic-common/src/byteview.rs
@@ -233,6 +233,41 @@ impl<'a> ByteView<'a> {
     pub fn as_slice(&self) -> &[u8] {
         self.backing.deref()
     }
+
+    /// Applies a [`AccessPattern`] hint to the backing storage.
+    ///
+    /// A hint can be applied when the predominantly access pattern
+    /// for this byte view is known.
+    ///
+    /// Applying the wrong hint may have significant effects on performance.
+    ///
+    /// Hints are applied on best effort basis, not all platforms
+    /// support the same hints, not all backing storages support
+    /// hints.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use std::io::Write;
+    /// use symbolic_common::{ByteView, AccessPattern};
+    ///
+    /// fn main() -> Result<(), std::io::Error> {
+    ///     let mut file = tempfile::tempfile()?;
+    ///     let view = ByteView::map_file_ref(&file)?;
+    ///     let _ = view.hint(AccessPattern::Random);
+    ///     Ok(())
+    /// }
+    /// ```
+    pub fn hint(&self, hint: AccessPattern) -> Result<(), io::Error> {
+        let _hint = hint; // silence unused lint
+        match self.backing.deref() {
+            ByteViewBacking::Buf(_) => Ok(()),
+            #[cfg(unix)]
+            ByteViewBacking::Mmap(mmap) => mmap.advise(_hint.to_madvise()),
+            #[cfg(not(unix))]
+            ByteViewBacking::Mmap(_) => Ok(()),
+        }
+    }
 }
 
 impl AsRef<[u8]> for ByteView<'_> {
@@ -253,6 +288,43 @@ impl Deref for ByteView<'_> {
 
 unsafe impl StableDeref for ByteView<'_> {}
 
+/// Values supported by [`ByteView::hint`].
+///
+/// This is largely an abstraction over [`madvise(2)`] and [`fadvise(2)`].
+///
+/// [`madvise(2)`]: https://man7.org/linux/man-pages/man2/madvise.2.html
+/// [`fadvise(2)`]: https://man7.org/linux/man-pages/man2/posix_fadvise.2.html
+#[derive(Debug, Default, Clone, Copy)]
+pub enum AccessPattern {
+    /// No special treatment.
+    ///
+    /// The operating system is in full control of the buffer,
+    /// a generally good default.
+    ///
+    /// This is the default.
+    #[default]
+    Normal,
+    /// Expect access to be random.
+    ///
+    /// Read ahead might be less useful than normally.
+    Random,
+    /// Expect access to be in sequential order, read ahead might be very useful.
+    /// After reading data there is a high chance it will not be accessed again
+    /// and can be aggressively freed.
+    Sequential,
+}
+
+impl AccessPattern {
+    #[cfg(unix)]
+    fn to_madvise(self) -> memmap2::Advice {
+        match self {
+            AccessPattern::Normal => memmap2::Advice::Normal,
+            AccessPattern::Random => memmap2::Advice::Random,
+            AccessPattern::Sequential => memmap2::Advice::Sequential,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/symbolic-common/src/cell.rs b/symbolic-common/src/cell.rs
index 19ce3d4eb..671422a40 100644
--- a/symbolic-common/src/cell.rs
+++ b/symbolic-common/src/cell.rs
@@ -80,7 +80,7 @@ pub trait AsSelf<'slf> {
     type Ref: ?Sized;
 
     /// Returns a reference to `self` with downcasted lifetime.
-    fn as_self(&'slf self) -> &Self::Ref;
+    fn as_self(&'slf self) -> &'slf Self::Ref;
 }
 
 impl AsSelf<'_> for u8 {
@@ -106,7 +106,7 @@ where
 {
     type Ref = [T::Ref];
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         unsafe { &*(self as *const [T] as *const [T::Ref]) }
     }
 }
@@ -117,7 +117,7 @@ where
 {
     type Ref = T::Ref;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         (*self).as_self()
     }
 }
@@ -128,7 +128,7 @@ where
 {
     type Ref = T::Ref;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         (**self).as_self()
     }
 }
@@ -140,7 +140,7 @@ where
 {
     type Ref = [T::Ref];
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         (**self).as_self()
     }
 }
@@ -151,7 +151,7 @@ where
 {
     type Ref = T::Ref;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         (**self).as_self()
     }
 }
@@ -162,7 +162,7 @@ where
 {
     type Ref = T::Ref;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         (**self).as_self()
     }
 }
@@ -368,7 +368,7 @@ mod tests {
     impl<'slf> AsSelf<'slf> for Foo<'_> {
         type Ref = Foo<'slf>;
 
-        fn as_self(&'slf self) -> &Self::Ref {
+        fn as_self(&'slf self) -> &'slf Self::Ref {
             self
         }
     }
diff --git a/symbolic-common/src/path.rs b/symbolic-common/src/path.rs
index 8772729ec..52bcfa021 100644
--- a/symbolic-common/src/path.rs
+++ b/symbolic-common/src/path.rs
@@ -54,7 +54,7 @@ fn is_windows_driveletter<P: AsRef<[u8]>>(path: P) -> bool {
 
     if let (Some(drive_letter), Some(b':')) = (path.first(), path.get(1)) {
         if drive_letter.is_ascii_alphabetic() {
-            return path.get(2).map_or(true, is_windows_separator);
+            return path.get(2).is_none_or(is_windows_separator);
         }
     }
 
@@ -69,11 +69,11 @@ fn is_absolute_windows_path<P: AsRef<[u8]>>(path: P) -> bool {
 
 /// Returns `true`
 fn is_semi_absolute_windows_path<P: AsRef<[u8]>>(path: P) -> bool {
-    path.as_ref().first().map_or(false, is_windows_separator)
+    path.as_ref().first().is_some_and(is_windows_separator)
 }
 
 fn is_absolute_unix_path<P: AsRef<[u8]>>(path: P) -> bool {
-    path.as_ref().first().map_or(false, is_unix_separator)
+    path.as_ref().first().is_some_and(is_unix_separator)
 }
 
 fn is_windows_path<P: AsRef<[u8]>>(path: P) -> bool {
diff --git a/symbolic-debuginfo/Cargo.toml b/symbolic-debuginfo/Cargo.toml
index 52e125307..428b2f498 100644
--- a/symbolic-debuginfo/Cargo.toml
+++ b/symbolic-debuginfo/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-debuginfo"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 authors = [
     "Armin Ronacher <armin.ronacher@active-4.com>",
@@ -13,7 +13,8 @@ description = """
 A library to inspect and load DWARF debugging information from binaries, such
 as Mach-O or ELF.
 """
-edition = "2021"
+edition.workspace = true
+rust-version.workspace = true
 
 exclude = ["tests/**/*"]
 
@@ -68,6 +69,7 @@ ms = [
     "pdb-addr2line",
     "scroll",
     "smallvec",
+    "srcsrv",
 ]
 ppdb = ["symbolic-ppdb"]
 # Source bundle creation
@@ -87,7 +89,6 @@ js = []
 wasm = ["dwarf", "wasmparser"]
 
 [dependencies]
-dmsort = { workspace = true }
 debugid = { workspace = true }
 elementtree = { workspace = true, optional = true }
 elsa = { workspace = true, optional = true }
@@ -106,8 +107,9 @@ scroll = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true, optional = true }
 smallvec = { workspace = true, optional = true }
-symbolic-common = { version = "12.9.2-dd", path = "../symbolic-common" }
-symbolic-ppdb = { version = "12.9.2-dd", path = "../symbolic-ppdb", optional = true }
+srcsrv = { version = "0.2", optional = true }
+symbolic-common = { version = "12.17.0-dd", path = "../symbolic-common" }
+symbolic-ppdb = { version = "12.17.0-dd", path = "../symbolic-ppdb", optional = true }
 thiserror = { workspace = true }
 wasmparser = { workspace = true, optional = true }
 zip = { workspace = true, optional = true }
@@ -116,6 +118,7 @@ zstd = { workspace = true, optional = true }
 [dev-dependencies]
 criterion = { workspace = true }
 insta = { workspace = true }
+proptest = {workspace = true }
 tempfile = { workspace = true }
 similar-asserts = { workspace = true }
 symbolic-testutils = { path = "../symbolic-testutils" }
diff --git a/symbolic-debuginfo/fuzz/Cargo.toml b/symbolic-debuginfo/fuzz/Cargo.toml
index 4a22260e6..bcb500ddf 100644
--- a/symbolic-debuginfo/fuzz/Cargo.toml
+++ b/symbolic-debuginfo/fuzz/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-debuginfo-fuzz"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 authors = ["Automatically generated"]
 publish = false
 edition = "2021"
diff --git a/symbolic-debuginfo/src/base.rs b/symbolic-debuginfo/src/base.rs
index b3c350817..92ea3a2a2 100644
--- a/symbolic-debuginfo/src/base.rs
+++ b/symbolic-debuginfo/src/base.rs
@@ -235,7 +235,7 @@ pub struct Symbol<'data> {
     pub size: u64,
 }
 
-impl<'data> Symbol<'data> {
+impl Symbol<'_> {
     /// Returns the name of this symbol as string.
     pub fn name(&self) -> Option<&str> {
         self.name.as_ref().map(Cow::as_ref)
@@ -251,7 +251,7 @@ impl<'data> Symbol<'data> {
     }
 }
 
-impl<'d> fmt::Debug for Symbol<'d> {
+impl fmt::Debug for Symbol<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Symbol")
             .field("name", &self.name().unwrap_or("<unknown>"))
@@ -351,7 +351,7 @@ impl<'data> SymbolMap<'data> {
         let end = match range.end_bound() {
             Bound::Included(end) => *end,
             Bound::Excluded(end) => *end - 1,
-            Bound::Unbounded => u64::max_value(),
+            Bound::Unbounded => u64::MAX,
         };
 
         if end <= start || symbol.contains(end) {
@@ -413,7 +413,7 @@ impl<'d> From<Vec<Symbol<'d>>> for SymbolMap<'d> {
             //
             // Inlined functions will generally not appear in this list, unless they _also_ have an
             // explicit function body, in which case they will have a unique address, again.
-            dmsort::sort_by_key(&mut symbols, Self::key);
+            symbols.sort_by_key(Self::key);
 
             // Compute sizes of consecutive symbols if the size has not been provided by the symbol
             // iterator. In the same go, drop all but the first symbols at any given address. We do
@@ -597,7 +597,7 @@ pub struct LineInfo<'data> {
 
 #[cfg(test)]
 impl LineInfo<'static> {
-    pub(crate) fn new(address: u64, size: u64, file: &[u8], line: u64) -> LineInfo {
+    pub(crate) fn new(address: u64, size: u64, file: &[u8], line: u64) -> LineInfo<'_> {
         LineInfo {
             address,
             size: Some(size),
diff --git a/symbolic-debuginfo/src/breakpad.rs b/symbolic-debuginfo/src/breakpad.rs
index 6c91aedbf..92cf2bdfe 100644
--- a/symbolic-debuginfo/src/breakpad.rs
+++ b/symbolic-debuginfo/src/breakpad.rs
@@ -605,7 +605,7 @@ pub struct BreakpadLineRecords<'d> {
     finished: bool,
 }
 
-impl<'d> Iterator for BreakpadLineRecords<'d> {
+impl Iterator for BreakpadLineRecords<'_> {
     type Item = Result<BreakpadLineRecord, BreakpadError>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -752,13 +752,13 @@ impl<'d> BreakpadStackCfiRecord<'d> {
     }
 }
 
-impl<'d> PartialEq for BreakpadStackCfiRecord<'d> {
+impl PartialEq for BreakpadStackCfiRecord<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.start == other.start && self.size == other.size && self.init_rules == other.init_rules
     }
 }
 
-impl<'d> Eq for BreakpadStackCfiRecord<'d> {}
+impl Eq for BreakpadStackCfiRecord<'_> {}
 
 /// An iterator over stack cfi delta records associated with a particular
 /// [`BreakpadStackCfiRecord`].
@@ -1159,7 +1159,7 @@ impl fmt::Debug for BreakpadObject<'_> {
 impl<'slf, 'data: 'slf> AsSelf<'slf> for BreakpadObject<'data> {
     type Ref = BreakpadObject<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
@@ -1263,7 +1263,7 @@ pub struct BreakpadDebugSession<'data> {
     lines: Lines<'data>,
 }
 
-impl<'data> BreakpadDebugSession<'data> {
+impl BreakpadDebugSession<'_> {
     /// Returns an iterator over all functions in this debug file.
     pub fn functions(&self) -> BreakpadFunctionIterator<'_> {
         BreakpadFunctionIterator::new(&self.file_map, self.lines.clone())
@@ -1285,7 +1285,7 @@ impl<'data> BreakpadDebugSession<'data> {
     }
 }
 
-impl<'data, 'session> DebugSession<'session> for BreakpadDebugSession<'data> {
+impl<'session> DebugSession<'session> for BreakpadDebugSession<'_> {
     type Error = BreakpadError;
     type FunctionIterator = BreakpadFunctionIterator<'session>;
     type FileIterator = BreakpadFileIterator<'session>;
@@ -1557,14 +1557,14 @@ mod parsing {
     }
 
     /// Parse a sequence of non-whitespace characters.
-    fn non_whitespace(input: &str) -> ParseResult<&str> {
+    fn non_whitespace(input: &str) -> ParseResult<'_, &str> {
         take_while(|c: char| !c.is_whitespace())(input)
     }
 
     /// Parse to the end of input and return the resulting string.
     ///
     /// If there is no input, return [`UNKNOWN_NAME`] instead.
-    fn name(input: &str) -> ParseResult<&str> {
+    fn name(input: &str) -> ParseResult<'_, &str> {
         rest.map(|name: &str| if name.is_empty() { UNKNOWN_NAME } else { name })
             .parse(input)
     }
@@ -1572,7 +1572,7 @@ mod parsing {
     /// Attempt to parse the character `m` followed by one or more spaces.
     ///
     /// Returns true if the parse was successful.
-    fn multiple(input: &str) -> ParseResult<bool> {
+    fn multiple(input: &str) -> ParseResult<'_, bool> {
         let (mut input, multiple) = char('m').opt().parse(input)?;
         let multiple = multiple.is_some();
         if multiple {
@@ -1582,14 +1582,14 @@ mod parsing {
     }
 
     /// Parse a line number as a signed decimal number and return `max(0, n)`.
-    fn line_num(input: &str) -> ParseResult<u64> {
+    fn line_num(input: &str) -> ParseResult<'_, u64> {
         pair(char('-').opt(), num_dec!(u64))
             .map(|(sign, num)| if sign.is_some() { 0 } else { num })
             .parse(input)
     }
 
     /// Parse a [`BreakpadStackWinRecordType`].
-    fn stack_win_record_type(input: &str) -> ParseResult<BreakpadStackWinRecordType> {
+    fn stack_win_record_type(input: &str) -> ParseResult<'_, BreakpadStackWinRecordType> {
         alt((
             char('0').value(BreakpadStackWinRecordType::Fpo),
             char('1').value(BreakpadStackWinRecordType::Trap),
@@ -1603,7 +1603,7 @@ mod parsing {
     /// Parse a [`BreakpadModuleRecord`].
     ///
     /// A module record has the form `MODULE <os> <arch> <id>( <name>)?`.
-    fn module_record(input: &str) -> ParseResult<BreakpadModuleRecord> {
+    fn module_record(input: &str) -> ParseResult<'_, BreakpadModuleRecord<'_>> {
         let (input, _) = tag("MODULE")
             .terminated(multispace1)
             .context("module record prefix")
@@ -1627,14 +1627,16 @@ mod parsing {
     ///
     /// A module record has the form `MODULE <os> <arch> <id>( <name>)?`.
     /// This will fail if there is any input left over after the record.
-    pub fn module_record_final(input: &str) -> Result<BreakpadModuleRecord, ErrorTree<ErrorLine>> {
+    pub fn module_record_final(
+        input: &str,
+    ) -> Result<BreakpadModuleRecord<'_>, ErrorTree<ErrorLine>> {
         nom_supreme::final_parser::final_parser(module_record)(input)
     }
 
     /// Parse the `CodeId` variant of a [`BreakpadInfoRecord`].
     ///
     /// A `CodeId` record has the form `CODE_ID <code_id>( <code_file>)?`.
-    fn info_code_id_record(input: &str) -> ParseResult<BreakpadInfoRecord> {
+    fn info_code_id_record(input: &str) -> ParseResult<'_, BreakpadInfoRecord<'_>> {
         let (input, _) = tag("CODE_ID")
             .terminated(multispace1)
             .context("info code_id record prefix")
@@ -1656,7 +1658,7 @@ mod parsing {
     /// Parse the `Other` variant of a [`BreakpadInfoRecord`].
     ///
     /// An `Other` record has the form `<scope>( <info>)?`.
-    fn info_other_record(input: &str) -> ParseResult<BreakpadInfoRecord> {
+    fn info_other_record(input: &str) -> ParseResult<'_, BreakpadInfoRecord<'_>> {
         let (input, (scope, info)) = pair(
             non_whitespace
                 .terminated(multispace1.or(eof))
@@ -1673,7 +1675,7 @@ mod parsing {
     /// Parse a [`BreakpadInfoRecord`].
     ///
     /// An INFO record has the form `INFO (<code_id_record> | <other_record>)`.
-    fn info_record(input: &str) -> ParseResult<BreakpadInfoRecord> {
+    fn info_record(input: &str) -> ParseResult<'_, BreakpadInfoRecord<'_>> {
         let (input, _) = tag("INFO")
             .terminated(multispace1)
             .context("info record prefix")
@@ -1690,14 +1692,14 @@ mod parsing {
     ///
     /// An INFO record has the form `INFO (<code_id_record> | <other_record>)`.
     /// This will fail if there is any input left over after the record.
-    pub fn info_record_final(input: &str) -> Result<BreakpadInfoRecord, ErrorTree<ErrorLine>> {
+    pub fn info_record_final(input: &str) -> Result<BreakpadInfoRecord<'_>, ErrorTree<ErrorLine>> {
         nom_supreme::final_parser::final_parser(info_record)(input)
     }
 
     /// Parse a [`BreakpadFileRecord`].
     ///
     /// A FILE record has the form `FILE <id>( <name>)?`.
-    fn file_record(input: &str) -> ParseResult<BreakpadFileRecord> {
+    fn file_record(input: &str) -> ParseResult<'_, BreakpadFileRecord<'_>> {
         let (input, _) = tag("FILE")
             .terminated(multispace1)
             .context("file record prefix")
@@ -1720,14 +1722,14 @@ mod parsing {
     ///
     /// A FILE record has the form `FILE <id>( <name>)?`.
     /// This will fail if there is any input left over after the record.
-    pub fn file_record_final(input: &str) -> Result<BreakpadFileRecord, ErrorTree<ErrorLine>> {
+    pub fn file_record_final(input: &str) -> Result<BreakpadFileRecord<'_>, ErrorTree<ErrorLine>> {
         nom_supreme::final_parser::final_parser(file_record)(input)
     }
 
     /// Parse a [`BreakpadInlineOriginRecord`].
     ///
     /// An INLINE_ORIGIN record has the form `INLINE_ORIGIN <id> <name>`.
-    fn inline_origin_record(input: &str) -> ParseResult<BreakpadInlineOriginRecord> {
+    fn inline_origin_record(input: &str) -> ParseResult<'_, BreakpadInlineOriginRecord<'_>> {
         let (input, _) = tag("INLINE_ORIGIN")
             .terminated(multispace1)
             .context("inline origin record prefix")
@@ -1752,14 +1754,14 @@ mod parsing {
     /// This will fail if there is any input left over after the record.
     pub fn inline_origin_record_final(
         input: &str,
-    ) -> Result<BreakpadInlineOriginRecord, ErrorTree<ErrorLine>> {
+    ) -> Result<BreakpadInlineOriginRecord<'_>, ErrorTree<ErrorLine>> {
         nom_supreme::final_parser::final_parser(inline_origin_record)(input)
     }
 
     /// Parse a [`BreakpadPublicRecord`].
     ///
     /// A PUBLIC record has the form `PUBLIC (m )? <address> <parameter_size> ( <name>)?`.
-    fn public_record(input: &str) -> ParseResult<BreakpadPublicRecord> {
+    fn public_record(input: &str) -> ParseResult<'_, BreakpadPublicRecord<'_>> {
         let (input, _) = tag("PUBLIC")
             .terminated(multispace1)
             .context("public record prefix")
@@ -1792,14 +1794,16 @@ mod parsing {
     ///
     /// A PUBLIC record has the form `PUBLIC (m )? <address> <parameter_size> ( <name>)?`.
     /// This will fail if there is any input left over after the record.
-    pub fn public_record_final(input: &str) -> Result<BreakpadPublicRecord, ErrorTree<ErrorLine>> {
+    pub fn public_record_final(
+        input: &str,
+    ) -> Result<BreakpadPublicRecord<'_>, ErrorTree<ErrorLine>> {
         nom_supreme::final_parser::final_parser(public_record)(input)
     }
 
     /// Parse a [`BreakpadFuncRecord`].
     ///
     /// A FUNC record has the form `FUNC (m )? <address> <size> <parameter_size> ( <name>)?`.
-    fn func_record(input: &str) -> ParseResult<BreakpadFuncRecord> {
+    fn func_record(input: &str) -> ParseResult<'_, BreakpadFuncRecord<'_>> {
         let (input, _) = tag("FUNC")
             .terminated(multispace1)
             .context("func record prefix")
@@ -1835,14 +1839,14 @@ mod parsing {
     ///
     /// A FUNC record has the form `FUNC (m )? <address> <size> <parameter_size> ( <name>)?`.
     /// This will fail if there is any input left over after the record.
-    pub fn func_record_final(input: &str) -> Result<BreakpadFuncRecord, ErrorTree<ErrorLine>> {
+    pub fn func_record_final(input: &str) -> Result<BreakpadFuncRecord<'_>, ErrorTree<ErrorLine>> {
         nom_supreme::final_parser::final_parser(func_record)(input)
     }
 
     /// Parse a [`BreakpadLineRecord`].
     ///
     /// A LINE record has the form `<address> <size> <line> <file_id>`.
-    fn line_record(input: &str) -> ParseResult<BreakpadLineRecord> {
+    fn line_record(input: &str) -> ParseResult<'_, BreakpadLineRecord> {
         let (input, (address, size, line, file_id)) = tuple((
             num_hex!(u64).terminated(multispace1).context("address"),
             num_hex!(u64).terminated(multispace1).context("size"),
@@ -1874,7 +1878,7 @@ mod parsing {
     /// Parse a [`BreakpadInlineRecord`].
     ///
     /// An INLINE record has the form `INLINE <inline_nest_level> <call_site_line> <call_site_file_id> <origin_id> [<address> <size>]+`.
-    fn inline_record(input: &str) -> ParseResult<BreakpadInlineRecord> {
+    fn inline_record(input: &str) -> ParseResult<'_, BreakpadInlineRecord> {
         let (input, _) = tag("INLINE")
             .terminated(multispace1)
             .context("inline record prefix")
@@ -1932,7 +1936,7 @@ mod parsing {
     /// Parse a [`BreakpadStackCfiDeltaRecord`].
     ///
     /// A STACK CFI Delta record has the form `STACK CFI <address> <rules>`.
-    fn stack_cfi_delta_record(input: &str) -> ParseResult<BreakpadStackCfiDeltaRecord> {
+    fn stack_cfi_delta_record(input: &str) -> ParseResult<'_, BreakpadStackCfiDeltaRecord<'_>> {
         let (input, _) = tag("STACK CFI")
             .terminated(multispace1)
             .context("stack cfi prefix")
@@ -1955,14 +1959,14 @@ mod parsing {
     /// This will fail if there is any input left over after the record.
     pub fn stack_cfi_delta_record_final(
         input: &str,
-    ) -> Result<BreakpadStackCfiDeltaRecord, ErrorTree<ErrorLine>> {
+    ) -> Result<BreakpadStackCfiDeltaRecord<'_>, ErrorTree<ErrorLine>> {
         nom_supreme::final_parser::final_parser(stack_cfi_delta_record)(input)
     }
 
     /// Parse a [`BreakpadStackCfiRecord`].
     ///
     /// A STACK CFI INIT record has the form `STACK CFI INIT <address> <size> <init_rules>`.
-    fn stack_cfi_record(input: &str) -> ParseResult<BreakpadStackCfiRecord> {
+    fn stack_cfi_record(input: &str) -> ParseResult<'_, BreakpadStackCfiRecord<'_>> {
         let (input, _) = tag("STACK CFI INIT")
             .terminated(multispace1)
             .context("stack cfi init  prefix")
@@ -1994,7 +1998,7 @@ mod parsing {
     /// This will fail if there is any input left over after the record.
     pub fn stack_cfi_record_final(
         input: &str,
-    ) -> Result<BreakpadStackCfiRecord, ErrorTree<ErrorLine>> {
+    ) -> Result<BreakpadStackCfiRecord<'_>, ErrorTree<ErrorLine>> {
         nom_supreme::final_parser::final_parser(stack_cfi_record)(input)
     }
 
@@ -2002,7 +2006,7 @@ mod parsing {
     ///
     /// A STACK WIN record has the form
     /// `STACK WIN <ty> <code_start> <code_size> <prolog_size> <epilog_size> <params_size> <saved_regs_size> <locals_size> <max_stack_size> <has_program_string> (<program_string> | <uses_base_pointer>)`.
-    fn stack_win_record(input: &str) -> ParseResult<BreakpadStackWinRecord> {
+    fn stack_win_record(input: &str) -> ParseResult<'_, BreakpadStackWinRecord<'_>> {
         let (input, _) = tag("STACK WIN")
             .terminated(multispace1)
             .context("stack win prefix")
@@ -2079,7 +2083,7 @@ mod parsing {
     /// This will fail if there is any input left over after the record.
     pub fn stack_win_record_final(
         input: &str,
-    ) -> Result<BreakpadStackWinRecord, ErrorTree<ErrorLine>> {
+    ) -> Result<BreakpadStackWinRecord<'_>, ErrorTree<ErrorLine>> {
         nom_supreme::final_parser::final_parser(stack_win_record)(input)
     }
 
@@ -2087,7 +2091,7 @@ mod parsing {
     /// [`BreakpadStackWinRecord`].
     ///
     /// This will fail if there is any input left over after the record.
-    pub fn stack_record_final(input: &str) -> Result<BreakpadStackRecord, ParseBreakpadError> {
+    pub fn stack_record_final(input: &str) -> Result<BreakpadStackRecord<'_>, ParseBreakpadError> {
         nom_supreme::final_parser::final_parser(alt((
             stack_cfi_record.map(BreakpadStackRecord::Cfi),
             stack_win_record.map(BreakpadStackRecord::Win),
@@ -2104,12 +2108,12 @@ mod tests {
         let record = BreakpadModuleRecord::parse(string)?;
 
         insta::assert_debug_snapshot!(record, @r#"
-       ⋮BreakpadModuleRecord {
-       ⋮    os: "Linux",
-       ⋮    arch: "x86_64",
-       ⋮    id: "492E2DD23CC306CA9C494EEF1533A3810",
-       ⋮    name: "crash",
-       ⋮}
+        BreakpadModuleRecord {
+            os: "Linux",
+            arch: "x86_64",
+            id: "492E2DD23CC306CA9C494EEF1533A3810",
+            name: "crash",
+        }
         "#);
 
         Ok(())
@@ -2122,12 +2126,12 @@ mod tests {
         let record = BreakpadModuleRecord::parse(string)?;
 
         insta::assert_debug_snapshot!(record, @r#"
-       ⋮BreakpadModuleRecord {
-       ⋮    os: "Linux",
-       ⋮    arch: "x86_64",
-       ⋮    id: "6216C672A8D33EC9CF4A1BAB8B29D00E",
-       ⋮    name: "libdispatch.so",
-       ⋮}
+        BreakpadModuleRecord {
+            os: "Linux",
+            arch: "x86_64",
+            id: "6216C672A8D33EC9CF4A1BAB8B29D00E",
+            name: "libdispatch.so",
+        }
         "#);
 
         Ok(())
@@ -2139,10 +2143,10 @@ mod tests {
         let record = BreakpadFileRecord::parse(string)?;
 
         insta::assert_debug_snapshot!(record, @r#"
-       ⋮BreakpadFileRecord {
-       ⋮    id: 37,
-       ⋮    name: "/usr/include/libkern/i386/_OSByteOrder.h",
-       ⋮}
+        BreakpadFileRecord {
+            id: 37,
+            name: "/usr/include/libkern/i386/_OSByteOrder.h",
+        }
         "#);
 
         Ok(())
@@ -2154,10 +2158,10 @@ mod tests {
         let record = BreakpadFileRecord::parse(string)?;
 
         insta::assert_debug_snapshot!(record, @r#"
-       ⋮BreakpadFileRecord {
-       ⋮    id: 38,
-       ⋮    name: "/usr/local/src/filename with spaces.c",
-       ⋮}
+        BreakpadFileRecord {
+            id: 38,
+            name: "/usr/local/src/filename with spaces.c",
+        }
         "#);
 
         Ok(())
@@ -2201,13 +2205,13 @@ mod tests {
         let record = BreakpadFuncRecord::parse(string, Lines::default())?;
 
         insta::assert_debug_snapshot!(record, @r#"
-       ⋮BreakpadFuncRecord {
-       ⋮    multiple: false,
-       ⋮    address: 5936,
-       ⋮    size: 26,
-       ⋮    parameter_size: 0,
-       ⋮    name: "<name omitted>",
-       ⋮}
+        BreakpadFuncRecord {
+            multiple: false,
+            address: 5936,
+            size: 26,
+            parameter_size: 0,
+            name: "<name omitted>",
+        }
         "#);
 
         Ok(())
@@ -2219,13 +2223,13 @@ mod tests {
         let record = BreakpadFuncRecord::parse(string, Lines::default())?;
 
         insta::assert_debug_snapshot!(record, @r#"
-       ⋮BreakpadFuncRecord {
-       ⋮    multiple: true,
-       ⋮    address: 5936,
-       ⋮    size: 26,
-       ⋮    parameter_size: 0,
-       ⋮    name: "<name omitted>",
-       ⋮}
+        BreakpadFuncRecord {
+            multiple: true,
+            address: 5936,
+            size: 26,
+            parameter_size: 0,
+            name: "<name omitted>",
+        }
         "#);
 
         Ok(())
@@ -2237,13 +2241,13 @@ mod tests {
         let record = BreakpadFuncRecord::parse(string, Lines::default())?;
 
         insta::assert_debug_snapshot!(record, @r#"
-       ⋮BreakpadFuncRecord {
-       ⋮    multiple: false,
-       ⋮    address: 0,
-       ⋮    size: 15,
-       ⋮    parameter_size: 0,
-       ⋮    name: "<unknown>",
-       ⋮}
+        BreakpadFuncRecord {
+            multiple: false,
+            address: 0,
+            size: 15,
+            parameter_size: 0,
+            name: "<unknown>",
+        }
         "#);
 
         Ok(())
@@ -2254,14 +2258,14 @@ mod tests {
         let string = b"1730 6 93 20";
         let record = BreakpadLineRecord::parse(string)?;
 
-        insta::assert_debug_snapshot!(record, @r###"
-       ⋮BreakpadLineRecord {
-       ⋮    address: 5936,
-       ⋮    size: 6,
-       ⋮    line: 93,
-       ⋮    file_id: 20,
-       ⋮}
-        "###);
+        insta::assert_debug_snapshot!(record, @r"
+        BreakpadLineRecord {
+            address: 5936,
+            size: 6,
+            line: 93,
+            file_id: 20,
+        }
+        ");
 
         Ok(())
     }
@@ -2271,14 +2275,14 @@ mod tests {
         let string = b"e0fd10 5 -376 2225";
         let record = BreakpadLineRecord::parse(string)?;
 
-        insta::assert_debug_snapshot!(record, @r###"
+        insta::assert_debug_snapshot!(record, @r"
         BreakpadLineRecord {
             address: 14744848,
             size: 5,
             line: 0,
             file_id: 2225,
         }
-        "###);
+        ");
 
         Ok(())
     }
@@ -2290,14 +2294,14 @@ mod tests {
         let record = BreakpadLineRecord::parse(string)?;
 
         insta::assert_debug_snapshot!(
-            record, @r###"
+            record, @r"
         BreakpadLineRecord {
             address: 4096,
             size: 28,
             line: 2972,
             file_id: 2,
         }
-        "###);
+        ");
 
         Ok(())
     }
@@ -2308,12 +2312,12 @@ mod tests {
         let record = BreakpadPublicRecord::parse(string)?;
 
         insta::assert_debug_snapshot!(record, @r#"
-       ⋮BreakpadPublicRecord {
-       ⋮    multiple: false,
-       ⋮    address: 20864,
-       ⋮    parameter_size: 0,
-       ⋮    name: "__clang_call_terminate",
-       ⋮}
+        BreakpadPublicRecord {
+            multiple: false,
+            address: 20864,
+            parameter_size: 0,
+            name: "__clang_call_terminate",
+        }
         "#);
 
         Ok(())
@@ -2325,12 +2329,12 @@ mod tests {
         let record = BreakpadPublicRecord::parse(string)?;
 
         insta::assert_debug_snapshot!(record, @r#"
-       ⋮BreakpadPublicRecord {
-       ⋮    multiple: true,
-       ⋮    address: 20864,
-       ⋮    parameter_size: 0,
-       ⋮    name: "__clang_call_terminate",
-       ⋮}
+        BreakpadPublicRecord {
+            multiple: true,
+            address: 20864,
+            parameter_size: 0,
+            name: "__clang_call_terminate",
+        }
         "#);
 
         Ok(())
@@ -2342,12 +2346,12 @@ mod tests {
         let record = BreakpadPublicRecord::parse(string)?;
 
         insta::assert_debug_snapshot!(record, @r#"
-       ⋮BreakpadPublicRecord {
-       ⋮    multiple: false,
-       ⋮    address: 20864,
-       ⋮    parameter_size: 0,
-       ⋮    name: "<unknown>",
-       ⋮}
+        BreakpadPublicRecord {
+            multiple: false,
+            address: 20864,
+            parameter_size: 0,
+            name: "<unknown>",
+        }
         "#);
 
         Ok(())
@@ -2358,7 +2362,7 @@ mod tests {
         let string = b"INLINE 0 3082 52 1410 49200 10";
         let record = BreakpadInlineRecord::parse(string)?;
 
-        insta::assert_debug_snapshot!(record, @r###"
+        insta::assert_debug_snapshot!(record, @r"
         BreakpadInlineRecord {
             inline_depth: 0,
             call_site_line: 3082,
@@ -2371,7 +2375,7 @@ mod tests {
                 },
             ],
         }
-        "###);
+        ");
 
         Ok(())
     }
@@ -2381,7 +2385,7 @@ mod tests {
         let string = b"INLINE 6 642 8 207 8b110 18 8b154 18";
         let record = BreakpadInlineRecord::parse(string)?;
 
-        insta::assert_debug_snapshot!(record, @r###"
+        insta::assert_debug_snapshot!(record, @r"
         BreakpadInlineRecord {
             inline_depth: 6,
             call_site_line: 642,
@@ -2398,7 +2402,7 @@ mod tests {
                 },
             ],
         }
-        "###);
+        ");
 
         Ok(())
     }
@@ -2469,7 +2473,7 @@ mod tests {
         let string = b"STACK WIN 3 8a10b ec b 0 c c 4 0 0 1";
         let record = BreakpadStackWinRecord::parse(string)?;
 
-        insta::assert_debug_snapshot!(record, @r###"
+        insta::assert_debug_snapshot!(record, @r"
         BreakpadStackWinRecord {
             ty: Standard,
             code_start: 565515,
@@ -2483,7 +2487,7 @@ mod tests {
             uses_base_pointer: true,
             program_string: None,
         }
-        "###);
+        ");
 
         Ok(())
     }
diff --git a/symbolic-debuginfo/src/dwarf.rs b/symbolic-debuginfo/src/dwarf.rs
index 2e41bc823..6de54b5b0 100644
--- a/symbolic-debuginfo/src/dwarf.rs
+++ b/symbolic-debuginfo/src/dwarf.rs
@@ -330,7 +330,7 @@ impl<'d> DwarfLineProgram<'d> {
         }
 
         // Sequences are not guaranteed to be in order.
-        dmsort::sort_by_key(&mut sequences, |x| x.start);
+        sequences.sort_by_key(|x| x.start);
 
         DwarfLineProgram {
             header: state_machine.header().clone(),
@@ -366,7 +366,7 @@ struct UnitRef<'d, 'a> {
     unit: &'a Unit<'d>,
 }
 
-impl<'d, 'a> UnitRef<'d, 'a> {
+impl<'d> UnitRef<'d, '_> {
     /// Resolve the binary value of an attribute.
     #[inline(always)]
     fn slice_value(&self, value: AttributeValue<Slice<'d>>) -> Option<&'d [u8]> {
@@ -996,7 +996,7 @@ struct FunctionsOutput<'a, 'd> {
     pub seen_ranges: &'a mut BTreeSet<(u64, u64)>,
 }
 
-impl<'a, 'd> FunctionsOutput<'a, 'd> {
+impl<'a> FunctionsOutput<'a, '_> {
     pub fn with_seen_ranges(seen_ranges: &'a mut BTreeSet<(u64, u64)>) -> Self {
         Self {
             functions: Vec::new(),
@@ -1097,6 +1097,8 @@ struct DwarfSections<'data> {
     debug_str_offsets: DwarfSectionData<'data, gimli::read::DebugStrOffsets<Slice<'data>>>,
     debug_ranges: DwarfSectionData<'data, gimli::read::DebugRanges<Slice<'data>>>,
     debug_rnglists: DwarfSectionData<'data, gimli::read::DebugRngLists<Slice<'data>>>,
+    debug_macinfo: DwarfSectionData<'data, gimli::read::DebugMacinfo<Slice<'data>>>,
+    debug_macro: DwarfSectionData<'data, gimli::read::DebugMacro<Slice<'data>>>,
 }
 
 impl<'data> DwarfSections<'data> {
@@ -1116,6 +1118,8 @@ impl<'data> DwarfSections<'data> {
             debug_str_offsets: DwarfSectionData::load(dwarf),
             debug_ranges: DwarfSectionData::load(dwarf),
             debug_rnglists: DwarfSectionData::load(dwarf),
+            debug_macinfo: DwarfSectionData::load(dwarf),
+            debug_macro: DwarfSectionData::load(dwarf),
         }
     }
 }
@@ -1156,6 +1160,8 @@ impl<'d> DwarfInfo<'d> {
             debug_str: sections.debug_str.to_gimli(),
             debug_str_offsets: sections.debug_str_offsets.to_gimli(),
             debug_types: Default::default(),
+            debug_macinfo: sections.debug_macinfo.to_gimli(),
+            debug_macro: sections.debug_macro.to_gimli(),
             locations: Default::default(),
             ranges: RangeLists::new(
                 sections.debug_ranges.to_gimli(),
@@ -1230,7 +1236,7 @@ impl<'d> DwarfInfo<'d> {
     }
 
     /// Returns an iterator over all compilation units.
-    fn units(&'d self, bcsymbolmap: Option<&'d BcSymbolMap<'d>>) -> DwarfUnitIterator<'_> {
+    fn units(&'d self, bcsymbolmap: Option<&'d BcSymbolMap<'d>>) -> DwarfUnitIterator<'d> {
         DwarfUnitIterator {
             info: self,
             bcsymbolmap,
@@ -1242,7 +1248,7 @@ impl<'d> DwarfInfo<'d> {
 impl<'slf, 'd: 'slf> AsSelf<'slf> for DwarfInfo<'d> {
     type Ref = DwarfInfo<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         unsafe { std::mem::transmute(self) }
     }
 }
@@ -1356,7 +1362,7 @@ impl<'data> DwarfDebugSession<'data> {
     }
 }
 
-impl<'data, 'session> DebugSession<'session> for DwarfDebugSession<'data> {
+impl<'session> DebugSession<'session> for DwarfDebugSession<'_> {
     type Error = DwarfError;
     type FunctionIterator = DwarfFunctionIterator<'session>;
     type FileIterator = DwarfFileIterator<'session>;
@@ -1487,3 +1493,23 @@ impl<'s> Iterator for DwarfFunctionIterator<'s> {
 }
 
 impl std::iter::FusedIterator for DwarfFunctionIterator<'_> {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::macho::MachObject;
+
+    #[cfg(feature = "macho")]
+    #[test]
+    fn test_loads_debug_str_offsets() {
+        // File generated using dsymutil
+
+        let data = std::fs::read("tests/fixtures/helloworld").unwrap();
+
+        let obj = MachObject::parse(&data).unwrap();
+
+        let sections = DwarfSections::from_dwarf(&obj);
+        assert_eq!(sections.debug_str_offsets.data.len(), 48);
+    }
+}
diff --git a/symbolic-debuginfo/src/elf.rs b/symbolic-debuginfo/src/elf.rs
index ed65c2fab..c5271abd1 100644
--- a/symbolic-debuginfo/src/elf.rs
+++ b/symbolic-debuginfo/src/elf.rs
@@ -76,7 +76,7 @@ impl<'data> ElfObject<'data> {
     /// Tests whether the buffer could contain an ELF object.
     pub fn test(data: &[u8]) -> bool {
         data.get(0..elf::header::SELFMAG)
-            .map_or(false, |data| data == elf::header::ELFMAG)
+            .is_some_and(|data| data == elf::header::ELFMAG)
     }
 
     // Pulled from https://github.com/m4b/goblin/blob/master/src/elf/mod.rs#L393-L424 as it
@@ -291,6 +291,30 @@ impl<'data> ElfObject<'data> {
                 return_partial_on_err!(elf::Symtab::parse(data, dyn_info.symtab, num_syms, ctx));
         }
 
+        // If the dynamic symbol table is empty, try finding a SHT_DYNSYM section in the section headers.
+        // See https://refspecs.linuxfoundation.org/LSB_2.1.0/LSB-Core-generic/LSB-Core-generic/elftypes.html:
+        //
+        // > This section holds a minimal set of symbols adequate for dynamic linking. See also SHT_SYMTAB. Currently, an object file may have either a section of SHT_SYMTAB type or a section of SHT_DYNSYM type, but not both.
+        if obj.dynsyms.is_empty() {
+            if let Some(shdr) = obj
+                .section_headers
+                .iter()
+                .find(|h| h.sh_type == elf::section_header::SHT_DYNSYM)
+            {
+                let size = shdr.sh_entsize;
+                let count = if size == 0 { 0 } else { shdr.sh_size / size };
+                obj.dynsyms = return_partial_on_err!(elf::Symtab::parse(
+                    data,
+                    shdr.sh_offset as usize,
+                    count as usize,
+                    ctx
+                ));
+
+                obj.dynstrtab =
+                    return_partial_on_err!(get_strtab(&obj.section_headers, shdr.sh_link as usize));
+            }
+        }
+
         obj.shdr_relocs = vec![];
         for (idx, section) in obj.section_headers.iter().enumerate() {
             let is_rela = section.sh_type == elf::section_header::SHT_RELA;
@@ -356,7 +380,7 @@ impl<'data> ElfObject<'data> {
     ///
     /// - None if there is no gnu_debuglink section
     /// - DebugLinkError if this section exists, but is malformed
-    pub fn debug_link(&self) -> Result<Option<DebugLink>, DebugLinkError> {
+    pub fn debug_link(&self) -> Result<Option<DebugLink<'_>>, DebugLinkError<'_>> {
         self.section("gnu_debuglink")
             .map(|section| DebugLink::from_data(section.data, self.endianity()))
             .transpose()
@@ -746,7 +770,7 @@ impl fmt::Debug for ElfObject<'_> {
 impl<'slf, 'data: 'slf> AsSelf<'slf> for ElfObject<'data> {
     type Ref = ElfObject<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
@@ -863,7 +887,7 @@ pub struct ElfSymbolIterator<'data, 'object> {
     load_addr: u64,
 }
 
-impl<'data, 'object> Iterator for ElfSymbolIterator<'data, 'object> {
+impl<'data> Iterator for ElfSymbolIterator<'data, '_> {
     type Item = Symbol<'data>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -891,7 +915,7 @@ impl<'data, 'object> Iterator for ElfSymbolIterator<'data, 'object> {
                 };
 
                 // We are only interested in symbols pointing into sections with executable flag.
-                if !section.map_or(false, |header| header.is_executable()) {
+                if !section.is_some_and(|header| header.is_executable()) {
                     continue;
                 }
 
@@ -939,6 +963,7 @@ impl<'data> DebugLink<'data> {
     /// - A filename, with any leading directory components removed, followed by a zero byte,
     /// - zero to three bytes of padding, as needed to reach the next four-byte boundary within the section, and
     /// - a four-byte CRC checksum, stored in the same endianness used for the executable file itself.
+    ///
     /// (from <https://sourceware.org/gdb/current/onlinedocs/gdb/Separate-Debug-Files.html#index-_002egnu_005fdebuglink-sections>)
     ///
     /// # Errors
diff --git a/symbolic-debuginfo/src/function_builder.rs b/symbolic-debuginfo/src/function_builder.rs
index af1ff4fd7..0bc2cad07 100644
--- a/symbolic-debuginfo/src/function_builder.rs
+++ b/symbolic-debuginfo/src/function_builder.rs
@@ -237,14 +237,14 @@ struct FunctionBuilderInlinee<'s> {
 }
 
 /// Implement ordering in DFS order, i.e. first by address and then by depth.
-impl<'s> PartialOrd for FunctionBuilderInlinee<'s> {
+impl PartialOrd for FunctionBuilderInlinee<'_> {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         Some(self.cmp(other))
     }
 }
 
 /// Implement ordering in DFS order, i.e. first by address and then by depth.
-impl<'s> Ord for FunctionBuilderInlinee<'s> {
+impl Ord for FunctionBuilderInlinee<'_> {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         (self.address, self.depth).cmp(&(other.address, other.depth))
     }
diff --git a/symbolic-debuginfo/src/js.rs b/symbolic-debuginfo/src/js.rs
index d47c88971..bf3341fe9 100644
--- a/symbolic-debuginfo/src/js.rs
+++ b/symbolic-debuginfo/src/js.rs
@@ -29,15 +29,23 @@ pub fn discover_sourcemaps_location(contents: &str) -> Option<&str> {
 }
 
 /// Quickly reads the embedded `debug_id` key from a source map.
+///
+/// Both `debugId` and `debug_id` are supported as field names. If both
+/// are set, the latter takes precedence.
 pub fn discover_sourcemap_embedded_debug_id(contents: &str) -> Option<DebugId> {
+    // Deserialize from `"debugId"` or `"debug_id"`,
+    // preferring the latter.
     #[derive(Deserialize)]
     struct DebugIdInSourceMap {
-        debug_id: Option<DebugId>,
+        #[serde(rename = "debugId")]
+        debug_id_new: Option<DebugId>,
+        #[serde(rename = "debug_id")]
+        debug_id_old: Option<DebugId>,
     }
 
     serde_json::from_str(contents)
         .ok()
-        .and_then(|x: DebugIdInSourceMap| x.debug_id)
+        .and_then(|x: DebugIdInSourceMap| x.debug_id_old.or(x.debug_id_new))
 }
 
 /// Parses a `debugId` comment in a file to discover a sourcemap's debug ID.
@@ -49,3 +57,59 @@ pub fn discover_debug_id(contents: &str) -> Option<DebugId> {
     }
     None
 }
+
+#[cfg(test)]
+mod tests {
+    use debugid::DebugId;
+
+    use crate::js::discover_sourcemap_embedded_debug_id;
+
+    #[test]
+    fn test_debugid_snake_case() {
+        let input = r#"{
+         "version":3,
+         "sources":["coolstuff.js"],
+         "names":["x","alert"],
+         "mappings":"AAAA,GAAIA,GAAI,EACR,IAAIA,GAAK,EAAG,CACVC,MAAM",
+         "debug_id":"00000000-0000-0000-0000-000000000000"
+     }"#;
+
+        assert_eq!(
+            discover_sourcemap_embedded_debug_id(input),
+            Some(DebugId::default())
+        );
+    }
+
+    #[test]
+    fn test_debugid_camel_case() {
+        let input = r#"{
+         "version":3,
+         "sources":["coolstuff.js"],
+         "names":["x","alert"],
+         "mappings":"AAAA,GAAIA,GAAI,EACR,IAAIA,GAAK,EAAG,CACVC,MAAM",
+         "debugId":"00000000-0000-0000-0000-000000000000"
+     }"#;
+
+        assert_eq!(
+            discover_sourcemap_embedded_debug_id(input),
+            Some(DebugId::default())
+        );
+    }
+
+    #[test]
+    fn test_debugid_both() {
+        let input = r#"{
+         "version":3,
+         "sources":["coolstuff.js"],
+         "names":["x","alert"],
+         "mappings":"AAAA,GAAIA,GAAI,EACR,IAAIA,GAAK,EAAG,CACVC,MAAM",
+         "debug_id":"00000000-0000-0000-0000-000000000000",
+         "debugId":"11111111-1111-1111-1111-111111111111"
+     }"#;
+
+        assert_eq!(
+            discover_sourcemap_embedded_debug_id(input),
+            Some(DebugId::default())
+        );
+    }
+}
diff --git a/symbolic-debuginfo/src/macho/bcsymbolmap.rs b/symbolic-debuginfo/src/macho/bcsymbolmap.rs
index 6a4c15e47..bd9c6c70d 100644
--- a/symbolic-debuginfo/src/macho/bcsymbolmap.rs
+++ b/symbolic-debuginfo/src/macho/bcsymbolmap.rs
@@ -78,7 +78,7 @@ impl From<BcSymbolMapErrorKind> for BcSymbolMapError {
 impl<'slf> AsSelf<'slf> for BcSymbolMap<'_> {
     type Ref = BcSymbolMap<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
@@ -194,7 +194,7 @@ pub struct BcSymbolMapIterator<'a, 'd> {
     iter: std::slice::Iter<'a, &'d str>,
 }
 
-impl<'a, 'd> Iterator for BcSymbolMapIterator<'a, 'd> {
+impl<'d> Iterator for BcSymbolMapIterator<'_, 'd> {
     type Item = &'d str;
 
     fn next(&mut self) -> Option<Self::Item> {
diff --git a/symbolic-debuginfo/src/macho/compact.rs b/symbolic-debuginfo/src/macho/compact.rs
index 4929a3b04..52d95a73f 100644
--- a/symbolic-debuginfo/src/macho/compact.rs
+++ b/symbolic-debuginfo/src/macho/compact.rs
@@ -272,7 +272,7 @@
 //! (subtract the global count to get the local index).
 //!
 //! > Unclear detail: If the global palette is smaller than 127, can the local
-//!   palette be larger than 128?
+//! > palette be larger than 128?
 //!
 //! To compress these entries into a single 32-bit value, the address is truncated
 //! to 24 bits and packed with the index. The addresses stored in these entries
@@ -2103,10 +2103,9 @@ mod test {
     const COMPRESSED_PAGE_KIND: u32 = 3;
 
     fn align(offset: u32, align: u32) -> u32 {
-        // Adding `align - 1` to a value push unaligned values to the next multiple,
-        // and integer division + multiplication can then remove the remainder.
-        ((offset + align - 1) / align) * align
+        offset.div_ceil(align) * align
     }
+
     fn pack_x86_rbp_registers(regs: [u8; 5]) -> u32 {
         let mut result: u32 = 0;
         let base_offset = 0;
@@ -2505,7 +2504,7 @@ mod test {
             let opcode = Opcode(
                 X86_MODE_RBP_FRAME
                     | pack_x86_rbp_registers(registers)
-                    | (stack_size as u32) << stack_size_offset,
+                    | ((stack_size as u32) << stack_size_offset),
             );
             let expected = vec![
                 CompactCfiOp::RegisterIs {
@@ -2537,7 +2536,7 @@ mod test {
             let opcode = Opcode(
                 X86_MODE_RBP_FRAME
                     | pack_x86_rbp_registers(registers)
-                    | (stack_size as u32) << stack_size_offset,
+                    | ((stack_size as u32) << stack_size_offset),
             );
             let expected = vec![
                 CompactCfiOp::RegisterIs {
@@ -2574,7 +2573,7 @@ mod test {
             let opcode = Opcode(
                 X86_MODE_RBP_FRAME
                     | pack_x86_rbp_registers(registers)
-                    | (stack_size as u32) << stack_size_offset,
+                    | ((stack_size as u32) << stack_size_offset),
             );
             let expected = vec![
                 CompactCfiOp::RegisterIs {
@@ -2631,7 +2630,7 @@ mod test {
             let opcode = Opcode(
                 X86_MODE_RBP_FRAME
                     | pack_x86_rbp_registers(registers)
-                    | (stack_size as u32) << stack_size_offset,
+                    | ((stack_size as u32) << stack_size_offset),
             );
             let expected = vec![
                 CompactCfiOp::RegisterIs {
@@ -2895,7 +2894,7 @@ mod test {
             let opcode = Opcode(
                 X86_MODE_RBP_FRAME
                     | pack_x86_rbp_registers(registers)
-                    | (stack_size as u32) << stack_size_offset,
+                    | ((stack_size as u32) << stack_size_offset),
             );
             let expected = vec![
                 CompactCfiOp::RegisterIs {
@@ -2927,7 +2926,7 @@ mod test {
             let opcode = Opcode(
                 X86_MODE_RBP_FRAME
                     | pack_x86_rbp_registers(registers)
-                    | (stack_size as u32) << stack_size_offset,
+                    | ((stack_size as u32) << stack_size_offset),
             );
             let expected = vec![
                 CompactCfiOp::RegisterIs {
@@ -2964,7 +2963,7 @@ mod test {
             let opcode = Opcode(
                 X86_MODE_RBP_FRAME
                     | pack_x86_rbp_registers(registers)
-                    | (stack_size as u32) << stack_size_offset,
+                    | ((stack_size as u32) << stack_size_offset),
             );
             let expected = vec![
                 CompactCfiOp::RegisterIs {
@@ -3021,7 +3020,7 @@ mod test {
             let opcode = Opcode(
                 X86_MODE_RBP_FRAME
                     | pack_x86_rbp_registers(registers)
-                    | (stack_size as u32) << stack_size_offset,
+                    | ((stack_size as u32) << stack_size_offset),
             );
             let expected = vec![
                 CompactCfiOp::RegisterIs {
diff --git a/symbolic-debuginfo/src/macho/mod.rs b/symbolic-debuginfo/src/macho/mod.rs
index 7fd53b399..85dbefb05 100644
--- a/symbolic-debuginfo/src/macho/mod.rs
+++ b/symbolic-debuginfo/src/macho/mod.rs
@@ -349,10 +349,8 @@ impl<'d> MachObject<'d> {
     ///
     /// This is an indication that BCSymbolMaps are needed to symbolicate crash reports correctly.
     pub fn requires_symbolmap(&self) -> bool {
-        self.symbols().any(|s| {
-            s.name()
-                .map_or(false, |n| n.starts_with(SWIFT_HIDDEN_PREFIX))
-        })
+        self.symbols()
+            .any(|s| s.name().is_some_and(|n| n.starts_with(SWIFT_HIDDEN_PREFIX)))
     }
 }
 
@@ -375,7 +373,7 @@ impl fmt::Debug for MachObject<'_> {
 impl<'slf, 'd: 'slf> AsSelf<'slf> for MachObject<'d> {
     type Ref = MachObject<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
@@ -468,7 +466,7 @@ impl<'data> Dwarf<'data> for MachObject<'data> {
             for section in segment.into_iter() {
                 let (header, data) = section.ok()?;
                 if let Ok(sec) = header.name() {
-                    if sec.starts_with("__") && &sec[2..] == section_name {
+                    if sec.starts_with("__") && map_section_name(&sec[2..]) == section_name {
                         // In some cases, dsymutil leaves sections headers but removes their
                         // data from the file. While the addr and size parameters are still
                         // set, `header.offset` is 0 in that case. We skip them just like the
@@ -492,6 +490,13 @@ impl<'data> Dwarf<'data> for MachObject<'data> {
     }
 }
 
+/// See <https://llvm.org/doxygen/MachOObjectFile_8cpp_source.html#l05341>.
+fn map_section_name(name: &str) -> &str {
+    match name {
+        "debug_str_offs" => "debug_str_offsets",
+        _ => name,
+    }
+}
 /// An iterator over symbols in the MachO file.
 ///
 /// Returned by [`MachObject::symbols`](struct.MachObject.html#method.symbols).
@@ -559,7 +564,7 @@ pub struct FatMachObjectIterator<'d, 'a> {
     data: &'d [u8],
 }
 
-impl<'d, 'a> Iterator for FatMachObjectIterator<'d, 'a> {
+impl<'d> Iterator for FatMachObjectIterator<'d, '_> {
     type Item = Result<MachObject<'d>, MachError>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -647,7 +652,7 @@ impl fmt::Debug for FatMachO<'_> {
 impl<'slf, 'd: 'slf> AsSelf<'slf> for FatMachO<'d> {
     type Ref = FatMachO<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
@@ -661,7 +666,7 @@ enum MachObjectIteratorInner<'d, 'a> {
 /// An iterator over objects in a [`MachArchive`](struct.MachArchive.html).
 pub struct MachObjectIterator<'d, 'a>(MachObjectIteratorInner<'d, 'a>);
 
-impl<'d, 'a> Iterator for MachObjectIterator<'d, 'a> {
+impl<'d> Iterator for MachObjectIterator<'d, '_> {
     type Item = Result<MachObject<'d>, MachError>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -796,13 +801,14 @@ impl<'d> MachArchive<'d> {
 impl<'slf, 'd: 'slf> AsSelf<'slf> for MachArchive<'d> {
     type Ref = MachArchive<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
 
 #[cfg(test)]
 mod tests {
+
     use super::*;
 
     #[test]
diff --git a/symbolic-debuginfo/src/object.rs b/symbolic-debuginfo/src/object.rs
index e3281ce7f..8cd5260f6 100644
--- a/symbolic-debuginfo/src/object.rs
+++ b/symbolic-debuginfo/src/object.rs
@@ -371,7 +371,7 @@ impl<'data> Object<'data> {
 impl<'slf, 'data: 'slf> AsSelf<'slf> for Object<'data> {
     type Ref = Object<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         unsafe { std::mem::transmute(self) }
     }
 }
@@ -449,7 +449,7 @@ pub enum ObjectDebugSession<'d> {
     PortablePdb(PortablePdbDebugSession<'d>),
 }
 
-impl<'d> ObjectDebugSession<'d> {
+impl ObjectDebugSession<'_> {
     /// Returns an iterator over all functions in this debug file.
     ///
     /// Functions are iterated in the order they are declared in their compilation units. The
@@ -606,7 +606,7 @@ pub enum SymbolIterator<'data, 'object> {
     PortablePdb(PortablePdbSymbolIterator<'data>),
 }
 
-impl<'data, 'object> Iterator for SymbolIterator<'data, 'object> {
+impl<'data> Iterator for SymbolIterator<'data, '_> {
     type Item = Symbol<'data>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -758,7 +758,7 @@ impl<'d> Archive<'d> {
 impl<'slf, 'd: 'slf> AsSelf<'slf> for Archive<'d> {
     type Ref = Archive<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         unsafe { std::mem::transmute(self) }
     }
 }
@@ -778,7 +778,7 @@ enum ObjectIteratorInner<'d, 'a> {
 /// An iterator over [`Object`](enum.Object.html)s in an [`Archive`](struct.Archive.html).
 pub struct ObjectIterator<'d, 'a>(ObjectIteratorInner<'d, 'a>);
 
-impl<'d, 'a> Iterator for ObjectIterator<'d, 'a> {
+impl<'d> Iterator for ObjectIterator<'d, '_> {
     type Item = Result<Object<'d>, ObjectError>;
 
     fn next(&mut self) -> Option<Self::Item> {
diff --git a/symbolic-debuginfo/src/pdb.rs b/symbolic-debuginfo/src/pdb.rs
index 9aa30e524..a13c423c6 100644
--- a/symbolic-debuginfo/src/pdb.rs
+++ b/symbolic-debuginfo/src/pdb.rs
@@ -16,6 +16,7 @@ use pdb_addr2line::pdb::{
 };
 use pdb_addr2line::ModuleProvider;
 use smallvec::SmallVec;
+use srcsrv;
 use thiserror::Error;
 
 use symbolic_common::{
@@ -251,6 +252,31 @@ impl<'data> PdbObject<'data> {
         false
     }
 
+    /// Returns the SRCSRV VCS integration name if available.
+    ///
+    /// This extracts the version control system identifier from the SRCSRV stream,
+    /// if present. Common values include "perforce", "tfs", "git", etc.
+    /// Returns `None` if no SRCSRV stream exists or if it cannot be parsed.
+    pub fn srcsrv_vcs_name(&self) -> Option<String> {
+        let mut pdb = self.pdb.write();
+
+        // Try to open the "srcsrv" named stream
+        let stream = match pdb.named_stream(b"srcsrv") {
+            Ok(stream) => stream,
+            Err(_) => return None,
+        };
+
+        // Parse the stream to extract VCS name
+        let stream_data = stream.as_slice();
+        if let Ok(parsed_stream) = srcsrv::SrcSrvStream::parse(stream_data) {
+            parsed_stream
+                .version_control_description()
+                .map(|s| s.to_string())
+        } else {
+            None
+        }
+    }
+
     /// Determines whether this object is malformed and was only partially parsed
     pub fn is_malformed(&self) -> bool {
         false
@@ -298,7 +324,7 @@ impl fmt::Debug for PdbObject<'_> {
 impl<'slf, 'data: 'slf> AsSelf<'slf> for PdbObject<'data> {
     type Ref = PdbObject<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         unsafe { std::mem::transmute(self) }
     }
 }
@@ -434,7 +460,7 @@ pub struct PdbSymbolIterator<'data, 'object> {
     executable_sections: &'object ExecutableSections,
 }
 
-impl<'data, 'object> Iterator for PdbSymbolIterator<'data, 'object> {
+impl<'data> Iterator for PdbSymbolIterator<'data, '_> {
     type Item = Symbol<'data>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -565,7 +591,7 @@ impl<'d> PdbDebugInfo<'d> {
     }
 
     /// Returns an iterator over all compilation units (modules).
-    fn units(&'d self) -> PdbUnitIterator<'_> {
+    fn units(&'d self) -> PdbUnitIterator<'d> {
         PdbUnitIterator {
             debug_info: self,
             index: 0,
@@ -576,7 +602,7 @@ impl<'d> PdbDebugInfo<'d> {
         self.type_formatter.modules()
     }
 
-    fn get_module(&'d self, index: usize) -> Result<Option<&ModuleInfo<'_>>, PdbError> {
+    fn get_module(&'d self, index: usize) -> Result<Option<&'d ModuleInfo<'d>>, PdbError> {
         // Silently ignore module references out-of-bound
         let module = match self.modules().get(index) {
             Some(module) => module,
@@ -599,7 +625,7 @@ impl<'d> PdbDebugInfo<'d> {
 impl<'slf, 'd: 'slf> AsSelf<'slf> for PdbDebugInfo<'d> {
     type Ref = PdbDebugInfo<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         unsafe { std::mem::transmute(self) }
     }
 }
@@ -746,6 +772,7 @@ impl<'s> Unit<'s> {
     /// For example we have observed in a real-world pdb that has:
     /// - A function 0x33ea50 (size 0xc)
     /// - With one line record: 0x33e850 (size 0x26)
+    ///
     /// The line record is completely outside the range of the function.
     fn sanitize_lines(func: &mut Function) {
         let fn_start = func.address;
@@ -905,7 +932,7 @@ impl<'s> Unit<'s> {
             if symbol.ends_scope() {
                 depth -= 1;
 
-                if proc_offsets.last().map_or(false, |&(d, _)| d >= depth) {
+                if proc_offsets.last().is_some_and(|&(d, _)| d >= depth) {
                     proc_offsets.pop();
                 }
             }
diff --git a/symbolic-debuginfo/src/pe.rs b/symbolic-debuginfo/src/pe.rs
index 146226e8e..e99cfcfbf 100644
--- a/symbolic-debuginfo/src/pe.rs
+++ b/symbolic-debuginfo/src/pe.rs
@@ -248,7 +248,7 @@ impl<'data> PeObject<'data> {
 
     /// Determines whether this object contains stack unwinding information.
     pub fn has_unwind_info(&self) -> bool {
-        !self.is_stub && self.exception_data().map_or(false, |e| !e.is_empty())
+        !self.is_stub && self.exception_data().is_some_and(|e| !e.is_empty())
     }
 
     /// Returns the raw data of the PE file.
@@ -377,7 +377,7 @@ impl fmt::Debug for PeObject<'_> {
 impl<'slf, 'data: 'slf> AsSelf<'slf> for PeObject<'data> {
     type Ref = PeObject<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
@@ -463,7 +463,7 @@ pub struct PeSymbolIterator<'data, 'object> {
     exports: std::slice::Iter<'object, pe::export::Export<'data>>,
 }
 
-impl<'data, 'object> Iterator for PeSymbolIterator<'data, 'object> {
+impl<'data> Iterator for PeSymbolIterator<'data, '_> {
     type Item = Symbol<'data>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -506,9 +506,9 @@ pub struct PeEmbeddedPortablePDB<'data> {
     uncompressed_size: usize,
 }
 
-impl<'data, 'object> PeEmbeddedPortablePDB<'data> {
+impl PeEmbeddedPortablePDB<'_> {
     /// Returns the uncompressed size of the Portable PDB buffer.
-    pub fn get_size(&'object self) -> usize {
+    pub fn get_size(&self) -> usize {
         self.uncompressed_size
     }
 
diff --git a/symbolic-debuginfo/src/ppdb.rs b/symbolic-debuginfo/src/ppdb.rs
index 25ae919f8..c22c96a70 100644
--- a/symbolic-debuginfo/src/ppdb.rs
+++ b/symbolic-debuginfo/src/ppdb.rs
@@ -26,7 +26,7 @@ pub struct PortablePdbObject<'data> {
 
 impl<'data> PortablePdbObject<'data> {
     /// Returns the Portable PDB contained in this object.
-    pub fn portable_pdb(&self) -> &PortablePdb {
+    pub fn portable_pdb(&self) -> &PortablePdb<'_> {
         &self.ppdb
     }
 
@@ -214,7 +214,7 @@ impl<'data> PortablePdbDebugSession<'data> {
     }
 }
 
-impl<'data, 'session> DebugSession<'session> for PortablePdbDebugSession<'data> {
+impl<'session> DebugSession<'session> for PortablePdbDebugSession<'_> {
     type Error = FormatError;
     type FunctionIterator = PortablePdbFunctionIterator<'session>;
     type FileIterator = PortablePdbFileIterator<'session>;
diff --git a/symbolic-debuginfo/src/sourcebundle.rs b/symbolic-debuginfo/src/sourcebundle/mod.rs
similarity index 91%
rename from symbolic-debuginfo/src/sourcebundle.rs
rename to symbolic-debuginfo/src/sourcebundle/mod.rs
index ebddd50e6..d87afe9a5 100644
--- a/symbolic-debuginfo/src/sourcebundle.rs
+++ b/symbolic-debuginfo/src/sourcebundle/mod.rs
@@ -42,14 +42,17 @@
 //! bundle a file entry has a `url` and might carry `headers` or individual debug IDs
 //! per source file.
 
+mod utf8_reader;
+
 use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::error::Error;
-use std::fmt;
+use std::fmt::{Display, Formatter};
 use std::fs::{File, OpenOptions};
-use std::io::{BufReader, BufWriter, Read, Seek, Write};
+use std::io::{BufReader, BufWriter, ErrorKind, Read, Seek, Write};
 use std::path::Path;
 use std::sync::Arc;
+use std::{fmt, io};
 
 use parking_lot::Mutex;
 use regex::Regex;
@@ -59,6 +62,7 @@ use zip::{write::SimpleFileOptions, ZipWriter};
 
 use symbolic_common::{Arch, AsSelf, CodeId, DebugId, SourceLinkMappings};
 
+use self::utf8_reader::Utf8Reader;
 use crate::base::*;
 use crate::js::{
     discover_debug_id, discover_sourcemap_embedded_debug_id, discover_sourcemaps_location,
@@ -84,7 +88,7 @@ lazy_static::lazy_static! {
 #[non_exhaustive]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum SourceBundleErrorKind {
-    /// The source bundle container is damanged.
+    /// The source bundle container is damaged.
     BadZip,
 
     /// An error when reading/writing the manifest.
@@ -550,7 +554,7 @@ impl<'data> SourceBundleIndex<'data> {
             let zip_path = Arc::new(zip_path.clone());
             if !file_info.path.is_empty() {
                 indexed_files.insert(
-                    FileKey::Path(file_info.path.clone().into()),
+                    FileKey::Path(normalize_path(&file_info.path).into()),
                     zip_path.clone(),
                 );
             }
@@ -783,7 +787,7 @@ impl<'data> SourceBundle<'data> {
 impl<'slf, 'data: 'slf> AsSelf<'slf> for SourceBundle<'data> {
     type Ref = SourceBundle<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         unsafe { std::mem::transmute(self) }
     }
 }
@@ -879,7 +883,7 @@ pub struct SourceBundleDebugSession<'data> {
     source_links: SourceLinkMappings,
 }
 
-impl<'data> SourceBundleDebugSession<'data> {
+impl SourceBundleDebugSession<'_> {
     /// Returns an iterator over all source files in this debug file.
     pub fn files(&self) -> SourceBundleFileIterator<'_> {
         SourceBundleFileIterator {
@@ -936,7 +940,7 @@ impl<'data> SourceBundleDebugSession<'data> {
         &self,
         path: &str,
     ) -> Result<Option<SourceFileDescriptor<'_>>, SourceBundleError> {
-        self.get_source_file_descriptor(FileKey::Path(path.into()))
+        self.get_source_file_descriptor(FileKey::Path(normalize_path(path).into()))
     }
 
     /// Like [`source_by_path`](Self::source_by_path) but looks up by URL.
@@ -969,7 +973,7 @@ impl<'data> SourceBundleDebugSession<'data> {
     }
 }
 
-impl<'data, 'session> DebugSession<'session> for SourceBundleDebugSession<'data> {
+impl<'session> DebugSession<'session> for SourceBundleDebugSession<'_> {
     type Error = SourceBundleError;
     type FunctionIterator = SourceBundleFunctionIterator<'session>;
     type FileIterator = SourceBundleFileIterator<'session>;
@@ -990,7 +994,7 @@ impl<'data, 'session> DebugSession<'session> for SourceBundleDebugSession<'data>
 impl<'slf, 'data: 'slf> AsSelf<'slf> for SourceBundleDebugSession<'data> {
     type Ref = SourceBundleDebugSession<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         unsafe { std::mem::transmute(self) }
     }
 }
@@ -1035,13 +1039,47 @@ fn sanitize_bundle_path(path: &str) -> String {
     sanitized
 }
 
+/// Normalizes all paths to follow the Linux standard of using forward slashes.
+fn normalize_path(path: &str) -> String {
+    path.replace('\\', "/")
+}
+
+/// Contains information about a file skipped in the SourceBundleWriter
+#[derive(Debug)]
+pub struct SkippedFileInfo<'a> {
+    path: &'a str,
+    reason: &'a str,
+}
+
+impl<'a> SkippedFileInfo<'a> {
+    fn new(path: &'a str, reason: &'a str) -> Self {
+        Self { path, reason }
+    }
+
+    /// Returns the path of the skipped file.
+    pub fn path(&self) -> &str {
+        self.path
+    }
+
+    /// Get the human-readable reason why the file was skipped
+    pub fn reason(&self) -> &str {
+        self.reason
+    }
+}
+
+impl Display for SkippedFileInfo<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "Skipped file {} due to: {}", self.path, self.reason)
+    }
+}
+
 /// Writer to create [`SourceBundles`].
 ///
 /// Writers can either [create a new file] or be created from an [existing file]. Then, use
 /// [`add_file`] to add files and finally call [`finish`] to flush the archive to
 /// the underlying writer.
 ///
-/// Note that dropping the writer
+/// Note that dropping the writer without calling [`finish`] will result in an incomplete bundle.
 ///
 /// ```no_run
 /// # use std::fs::File;
@@ -1070,6 +1108,7 @@ where
     manifest: SourceBundleManifest,
     writer: ZipWriter<W>,
     collect_il2cpp: bool,
+    skipped_file_callback: Box<dyn FnMut(SkippedFileInfo)>,
 }
 
 fn default_file_options() -> SimpleFileOptions {
@@ -1097,6 +1136,7 @@ where
             manifest: SourceBundleManifest::new(),
             writer: ZipWriter::new(writer),
             collect_il2cpp: false,
+            skipped_file_callback: Box::new(|_| ()),
         })
     }
 
@@ -1185,18 +1225,14 @@ where
     pub fn add_file<S, R>(
         &mut self,
         path: S,
-        mut file: R,
+        file: R,
         info: SourceFileInfo,
     ) -> Result<(), SourceBundleError>
     where
         S: AsRef<str>,
         R: Read,
     {
-        let mut buf = String::new();
-
-        if let Err(e) = file.read_to_string(&mut buf) {
-            return Err(SourceBundleError::new(SourceBundleErrorKind::ReadFailed, e));
-        }
+        let mut file_reader = Utf8Reader::new(file);
 
         let full_path = self.file_path(path.as_ref());
         let unique_path = self.unique_path(full_path);
@@ -1204,12 +1240,62 @@ where
         self.writer
             .start_file(unique_path.clone(), default_file_options())
             .map_err(|e| SourceBundleError::new(SourceBundleErrorKind::WriteFailed, e))?;
-        self.writer
-            .write_all(buf.as_bytes())
-            .map_err(|e| SourceBundleError::new(SourceBundleErrorKind::WriteFailed, e))?;
 
-        self.manifest.files.insert(unique_path, info);
-        Ok(())
+        match io::copy(&mut file_reader, &mut self.writer) {
+            Err(e) => {
+                self.writer
+                    .abort_file()
+                    .map_err(|e| SourceBundleError::new(SourceBundleErrorKind::WriteFailed, e))?;
+
+                // ErrorKind::InvalidData is returned by Utf8Reader when the file is not valid UTF-8.
+                let error_kind = match e.kind() {
+                    ErrorKind::InvalidData => SourceBundleErrorKind::ReadFailed,
+                    _ => SourceBundleErrorKind::WriteFailed,
+                };
+
+                Err(SourceBundleError::new(error_kind, e))
+            }
+            Ok(_) => {
+                self.manifest.files.insert(unique_path, info);
+                Ok(())
+            }
+        }
+    }
+
+    /// Calls add_file, and handles any ReadFailed errors by calling the skipped_file_callback.
+    fn add_file_skip_read_failed<S, R>(
+        &mut self,
+        path: S,
+        file: R,
+        info: SourceFileInfo,
+    ) -> Result<(), SourceBundleError>
+    where
+        S: AsRef<str>,
+        R: Read,
+    {
+        let result = self.add_file(&path, file, info);
+
+        if let Err(e) = &result {
+            if e.kind == SourceBundleErrorKind::ReadFailed {
+                let reason = e.to_string();
+                let skipped_info = SkippedFileInfo::new(path.as_ref(), &reason);
+                (self.skipped_file_callback)(skipped_info);
+
+                return Ok(());
+            }
+        }
+
+        result
+    }
+
+    /// Set a callback, which is called for every file that is skipped from being included in the
+    /// source bundle. The callback receives information about the file being skipped.
+    pub fn with_skipped_file_callback(
+        mut self,
+        callback: impl FnMut(SkippedFileInfo) + 'static,
+    ) -> Self {
+        self.skipped_file_callback = Box::new(callback);
+        self
     }
 
     /// Writes a single object into the bundle.
@@ -1297,7 +1383,7 @@ where
                     collect_il2cpp_sources(&source, &mut referenced_files);
                 }
 
-                self.add_file(bundle_path, source.as_slice(), info)?;
+                self.add_file_skip_read_failed(bundle_path, source.as_slice(), info)?;
             }
 
             files_handled.insert(filename);
@@ -1314,7 +1400,7 @@ where
                 info.set_ty(SourceFileType::Source);
                 info.set_path(filename.clone());
 
-                self.add_file(bundle_path, source, info)?;
+                self.add_file_skip_read_failed(bundle_path, source, info)?
             }
         }
 
@@ -1470,6 +1556,50 @@ mod tests {
         is_sendsync::<SourceBundleDebugSession>();
     }
 
+    #[test]
+    fn test_normalize_paths() -> Result<(), SourceBundleError> {
+        let mut writer = Cursor::new(Vec::new());
+        let mut bundle = SourceBundleWriter::start(&mut writer)?;
+
+        for filename in &[
+            "C:\\users\\martin\\mydebugfile.cs",
+            "/usr/martin/mydebugfile.h",
+        ] {
+            let mut info = SourceFileInfo::new();
+            info.set_ty(SourceFileType::Source);
+            info.set_path(filename.to_string());
+            bundle.add_file_skip_read_failed(
+                sanitize_bundle_path(filename),
+                &b"somerandomdata"[..],
+                info,
+            )?;
+        }
+
+        bundle.finish()?;
+        let bundle_bytes = writer.into_inner();
+        let bundle = SourceBundle::parse(&bundle_bytes)?;
+
+        let session = bundle.debug_session().unwrap();
+
+        assert!(session
+            .source_by_path("C:\\users\\martin\\mydebugfile.cs")?
+            .is_some());
+        assert!(session
+            .source_by_path("C:/users/martin/mydebugfile.cs")?
+            .is_some());
+        assert!(session
+            .source_by_path("C:\\users\\martin/mydebugfile.cs")?
+            .is_some());
+        assert!(session
+            .source_by_path("/usr/martin/mydebugfile.h")?
+            .is_some());
+        assert!(session
+            .source_by_path("\\usr\\martin\\mydebugfile.h")?
+            .is_some());
+
+        Ok(())
+    }
+
     #[test]
     fn test_source_descriptor() -> Result<(), SourceBundleError> {
         let mut writer = Cursor::new(Vec::new());
diff --git a/symbolic-debuginfo/src/sourcebundle/utf8_reader.rs b/symbolic-debuginfo/src/sourcebundle/utf8_reader.rs
new file mode 100644
index 000000000..64713814e
--- /dev/null
+++ b/symbolic-debuginfo/src/sourcebundle/utf8_reader.rs
@@ -0,0 +1,306 @@
+//! UTF-8 reader used by the sourcebundle module to read files.
+
+use std::cmp;
+use std::io::{Error, ErrorKind, Read, Result};
+use std::str;
+
+use thiserror::Error;
+
+const MAX_UTF8_SEQUENCE_SIZE: usize = 4;
+
+#[derive(Debug, Error)]
+#[error("Invalid UTF-8 sequence")]
+pub(crate) struct UTF8ReaderError;
+
+pub struct Utf8Reader<R> {
+    inner: R,
+
+    /// A buffer of `MAX_UTF8_SEQUENCE_SIZE` bytes, which we use when the end of a read is not a
+    /// valid UTF-8 sequence. We read into this buffer until we have a valid UTF-8 sequence, or
+    /// the reader is exhausted, or the buffer is full. Assuming we get a valid UTF-8 sequence,
+    /// we then on next read read from this buffer.
+    buffer: [u8; MAX_UTF8_SEQUENCE_SIZE],
+
+    /// The index of the first byte in the buffer that has not been read.
+    buffer_start: usize,
+
+    /// The index of the last byte in the buffer that is part of the UTF-8 sequence. We only read
+    /// up to this index, bytes after this index are discarded.
+    buffer_end: usize,
+}
+
+impl<R> Utf8Reader<R> {
+    pub fn new(inner: R) -> Self {
+        Self {
+            inner,
+            buffer: [0; MAX_UTF8_SEQUENCE_SIZE],
+            buffer_start: 0,
+            buffer_end: 0,
+        }
+    }
+
+    /// The slice of the buffer that should be read next.
+    fn buffer_to_read(&self) -> &[u8] {
+        &self.buffer[self.buffer_start..self.buffer_end]
+    }
+
+    /// Advances the buffer start index by the given amount.
+    fn advance(&mut self, amt: usize) {
+        self.buffer_start += amt;
+    }
+
+    /// Reads bytes from the buffer into the given buffer.
+    fn read_from_buffer(&mut self, buf: &mut [u8]) -> Result<usize> {
+        let bytes_copied = slice_copy(buf, self.buffer_to_read());
+        self.advance(bytes_copied);
+
+        Ok(bytes_copied)
+    }
+}
+
+impl<R> Utf8Reader<R>
+where
+    R: Read,
+{
+    /// Reads bytes from the inner reader into the given buffer.
+    ///
+    /// If a UTF-8 sequence only partially fits into the buffer, the remaining
+    /// bytes are written to `self.buffer`.
+    fn read_from_inner(&mut self, buf: &mut [u8]) -> Result<usize> {
+        let read_from_inner = self.inner.read(buf)?;
+        let read_portion = &buf[..read_from_inner];
+
+        let invalid_portion = ending_incomplete_utf8_sequence(read_portion)?;
+
+        slice_copy(&mut self.buffer, invalid_portion);
+        self.read_into_buffer_until_utf8(invalid_portion.len())?;
+
+        Ok(read_from_inner)
+    }
+
+    /// Reads bytes from the inner reader into self.buffer until the buffer contains a valid UTF-8
+    /// sequence.
+    ///
+    /// Before calling this method, self.buffer[..start_index] should contain the bytes that are
+    /// part of the incomplete UTF-8 sequence that we are trying to complete (or, it should be
+    /// empty, in which case, this function is a no-op)
+    ///
+    /// Then, we read one byte at a time from the inner reader into self.buffer, until we have a
+    /// valid UTF-8 sequence.
+    ///
+    /// Lastly, we set self.buffer_start to start_index (so we don't reread the bytes that started
+    /// the incomplete UTF-8 sequence) and self.buffer_end to the index of the last byte in the
+    /// buffer that is part of the UTF-8 sequence.
+    ///
+    /// The next read from the Utf8Reader will read from
+    /// self.buffer[self.buffer_start..self.buffer_end].
+    fn read_into_buffer_until_utf8(&mut self, start_index: usize) -> Result<()> {
+        let bytes_until_utf8 = read_until_utf8(&mut self.inner, &mut self.buffer, start_index)?;
+
+        self.buffer_start = start_index;
+        self.buffer_end = bytes_until_utf8;
+
+        Ok(())
+    }
+}
+
+impl<R> Read for Utf8Reader<R>
+where
+    R: Read,
+{
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        let read_from_buffer = self.read_from_buffer(buf)?;
+
+        // self.read_from_inner overwrites self.buffer, so we can only call it if we have read
+        // everything from the buffer.
+        let read_from_inner = match self.buffer_to_read() {
+            [] => self.read_from_inner(&mut buf[read_from_buffer..])?,
+            _ => 0,
+        };
+
+        Ok(read_from_buffer + read_from_inner)
+    }
+}
+
+/// Reads a single byte at a time from the inner reader into the buffer, starting from
+/// current_index, until either the buffer contains a valid UTF-8 sequence, the reader is
+/// exhausted, or the 4 bytes total have been read into the buffer (the maximum size of a
+/// UTF-8 sequence). The 4 bytes also includes bytes already in the buffer when the function is
+/// called, as indicated by the current_index parameter.
+///
+/// If the buffer is empty (i.e. current_index is 0), we will return Ok(0) without reading
+/// anything from the reader. An empty byte sequence is a valid UTF-8 sequence (the
+/// empty string).
+///
+/// Returns the number of bytes read into the buffer (including bytes already in the buffer
+/// when the function is called), or an error if the reader errors or if reading a valid UTF-8
+/// sequence is not possible.
+///
+/// The buffer must have a length of at least 4, otherwise this function can panic.
+fn read_until_utf8(
+    reader: &mut impl Read,
+    buffer: &mut [u8],
+    mut current_index: usize,
+) -> Result<usize> {
+    while str::from_utf8(&buffer[..current_index]).is_err() {
+        if current_index >= MAX_UTF8_SEQUENCE_SIZE
+            || reader.read(&mut buffer[current_index..current_index + 1])? == 0
+        {
+            // We already have 4 bytes in the buffer (maximum UTF-8 sequence size), or the stream
+            // has been exhausted without finding a valid UTF-8 sequence.
+            return Err(Error::new(ErrorKind::InvalidData, UTF8ReaderError));
+        }
+
+        current_index += 1;
+    }
+
+    Ok(current_index)
+}
+
+/// Returns the index of the first invalid UTF-8 sequence
+/// in the given bytes. If the sequence is valid, returns the
+/// length of the bytes.
+fn utf8_up_to(bytes: &[u8]) -> usize {
+    match str::from_utf8(bytes) {
+        Ok(_) => bytes.len(),
+        Err(e) => e.valid_up_to(),
+    }
+}
+
+/// Given a byte slice, determines if the slice ends in what might be an incomplete UTF-8 sequence,
+/// returning the incomplete sequence if so.
+///
+/// The following return values are possible:
+///   - Ok([]) if the byte slice is valid UTF-8, in its entirety.
+///   - Ok(incomplete_sequence) if the byte slice is valid up to the `incomplete_sequence` slice
+///     returned by this function. `incomplete_sequence` is always a slice of at most 3 bytes
+///     occurring at the end of the input slice. In this case, it might be possible to make the
+///     input slice a valid UTF-8 sequence by appending bytes to the input slice.
+///   - Err(e) if the first UTF-8 violation in the input slice occurs more than 3 bytes from the
+///     end of the input slice. In this case, it is definitely not possible to make the sequence
+///     valid by appending bytes to the input slice.
+fn ending_incomplete_utf8_sequence(bytes: &[u8]) -> Result<&[u8]> {
+    let valid_up_to = utf8_up_to(bytes);
+    let invalid_portion = &bytes[valid_up_to..];
+
+    if invalid_portion.len() >= MAX_UTF8_SEQUENCE_SIZE {
+        Err(Error::new(ErrorKind::InvalidData, UTF8ReaderError))
+    } else {
+        Ok(invalid_portion)
+    }
+}
+
+/// Copies as many elements as possible (i.e. the smaller of the two slice lengths) from the
+/// beginning of the source slice to the beginning of the destination slice, overwriting anything
+/// already in the destination slice.
+///
+/// Returns the number of elements copied.
+fn slice_copy<T>(dst: &mut [T], src: &[T]) -> usize
+where
+    T: Copy,
+{
+    let elements_to_copy = cmp::min(dst.len(), src.len());
+    dst[..elements_to_copy].copy_from_slice(&src[..elements_to_copy]);
+
+    elements_to_copy
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use proptest::prelude::*;
+
+    use core::str;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_read_empty() {
+        let mut empty_reader = Utf8Reader::new(Cursor::new(b""));
+
+        let mut buf = vec![];
+        empty_reader
+            .read_to_end(&mut buf)
+            .expect("read_to_end errored");
+
+        assert_eq!(buf, b"");
+    }
+
+    #[test]
+    fn test_read_ascii_simple() {
+        let mut reader = Utf8Reader::new(Cursor::new(b"Hello, world!"));
+
+        let mut buf = vec![];
+        reader.read_to_end(&mut buf).expect("read_to_end errored");
+
+        assert_eq!(buf, b"Hello, world!");
+    }
+
+    #[test]
+    fn test_read_utf8_simple() {
+        const HELLO_WORLD: &str = "你好世界！";
+        let mut reader = Utf8Reader::new(Cursor::new(HELLO_WORLD.as_bytes()));
+
+        let mut buf = vec![];
+        reader.read_to_end(&mut buf).expect("read_to_end errored");
+
+        assert_eq!(buf, HELLO_WORLD.as_bytes());
+    }
+
+    #[test]
+    fn small_reads_splitting_sequence() {
+        let mut reader = Utf8Reader::new(Cursor::new("🙂".as_bytes()));
+
+        let mut buf = [0; MAX_UTF8_SEQUENCE_SIZE];
+
+        for i in 0..MAX_UTF8_SEQUENCE_SIZE {
+            // Read at most one byte at a time.
+            let bytes_read = reader.read(&mut buf[i..i + 1]).expect("read errored");
+            assert_eq!(bytes_read, 1, "bytes read");
+        }
+
+        assert_eq!(&buf[..], "🙂".as_bytes());
+    }
+
+    #[test]
+    fn invalid_utf8_sequence() {
+        let mut reader = Utf8Reader::new(Cursor::new([0b11111111]));
+
+        let mut buf = [0; 1];
+        reader.read(&mut buf).expect_err("read should have errored");
+    }
+
+    #[test]
+    fn invalid_utf8_sequence_at_end_of_reader() {
+        let mut read_buffer = Vec::from(b"Hello, world!");
+
+        // Cutting off the last byte will invalidate the UTF-8 sequence.
+        let invalid_sequence = &"🙂".as_bytes()[..'🙂'.len_utf8() - 1];
+        read_buffer.extend(invalid_sequence);
+
+        let mut reader = Utf8Reader::new(Cursor::new(&read_buffer));
+        reader
+            .read_to_end(&mut vec![])
+            .expect_err("read should have errored");
+    }
+
+    proptest! {
+        #[test]
+        fn read_arbitrary_string(s in any::<String>()) {
+            let mut buf = vec![];
+            let mut reader = Utf8Reader::new(Cursor::new(&s));
+
+            reader.read_to_end(&mut buf).unwrap();
+            assert_eq!(str::from_utf8(&buf).unwrap(), s);
+        }
+
+        #[test]
+        fn dont_read_arbitrary_nonstring(s in any::<Vec<u8>>()) {
+            prop_assume!(str::from_utf8(&s).is_err());
+            let mut buf = vec![];
+            let mut reader = Utf8Reader::new(Cursor::new(&s));
+
+            reader.read_to_end(&mut buf).unwrap_err();
+        }
+    }
+}
diff --git a/symbolic-debuginfo/src/wasm.rs b/symbolic-debuginfo/src/wasm.rs
index 1454f2f49..bafd252d3 100644
--- a/symbolic-debuginfo/src/wasm.rs
+++ b/symbolic-debuginfo/src/wasm.rs
@@ -169,7 +169,7 @@ impl fmt::Debug for WasmObject<'_> {
 impl<'slf, 'd: 'slf> AsSelf<'slf> for WasmObject<'d> {
     type Ref = WasmObject<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
@@ -278,7 +278,7 @@ pub struct WasmSymbolIterator<'data, 'object> {
     _marker: std::marker::PhantomData<&'object u8>,
 }
 
-impl<'data, 'object> Iterator for WasmSymbolIterator<'data, 'object> {
+impl<'data> Iterator for WasmSymbolIterator<'data, '_> {
     type Item = Symbol<'data>;
 
     fn next(&mut self) -> Option<Self::Item> {
diff --git a/symbolic-debuginfo/src/wasm/parser.rs b/symbolic-debuginfo/src/wasm/parser.rs
index f6413ce48..1fa4fd5b7 100644
--- a/symbolic-debuginfo/src/wasm/parser.rs
+++ b/symbolic-debuginfo/src/wasm/parser.rs
@@ -3,8 +3,8 @@
 use super::WasmError;
 use crate::base::{ObjectKind, Symbol};
 use wasmparser::{
-    BinaryReader, CompositeType, FuncValidatorAllocations, NameSectionReader, Payload, TypeRef,
-    Validator, WasmFeatures,
+    BinaryReader, CompositeInnerType, FuncValidatorAllocations, NameSectionReader, Payload,
+    TypeRef, Validator, WasmFeatures,
 };
 
 #[derive(Default)]
@@ -20,7 +20,7 @@ impl BitVec {
 
     pub fn resize(&mut self, count: usize, value: bool) {
         self.data.resize(
-            (count + u64::BITS as usize - 1) / u64::BITS as usize,
+            count.div_ceil(u64::BITS as usize),
             if value { u64::MAX } else { u64::MIN },
         );
         self.len = count;
@@ -43,7 +43,7 @@ impl BitVec {
         } else {
             let vec_index = index / u64::BITS as usize;
             let item_bit = index % u64::BITS as usize;
-            Some(self.data[vec_index] & 1 << item_bit != 0)
+            Some(self.data[vec_index] & (1 << item_bit) != 0)
         }
     }
 }
@@ -83,8 +83,8 @@ impl<'data> super::WasmObject<'data> {
                     for (i, ty) in tsr.into_iter().enumerate() {
                         let mut types = ty?.into_types();
                         let ty_is_func = matches!(
-                            types.next().map(|s| s.composite_type),
-                            Some(CompositeType::Func(_))
+                            types.next().map(|s| s.composite_type.inner),
+                            Some(CompositeInnerType::Func(_))
                         );
                         if types.next().is_none() && ty_is_func {
                             func_sigs.set(i, true);
diff --git a/symbolic-debuginfo/tests/fixtures/helloworld b/symbolic-debuginfo/tests/fixtures/helloworld
new file mode 100644
index 000000000..2aed7c6cc
Binary files /dev/null and b/symbolic-debuginfo/tests/fixtures/helloworld differ
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_files.snap b/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_files.snap
index 626dc6650..44a7eb330 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_files.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_files.snap
@@ -1,7 +1,5 @@
 ---
-created: "2019-06-28T08:09:53.890090Z"
-creator: insta@0.8.1
-source: debuginfo/tests/test_objects.rs
+source: symbolic-debuginfo/tests/test_objects.rs
 expression: "FilesDebug(&files[..10])"
 ---
 c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.13.26128\include\system_error
@@ -14,4 +12,3 @@ c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.1
 c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.13.26128\include\xstring
 c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.13.26128\include\cstdlib
 c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.13.26128\include\xmemory0
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_functions.snap b/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_functions.snap
index bf64859e4..3d056fd74 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_functions.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_functions.snap
@@ -1,10 +1,7 @@
 ---
-created: "2019-02-20T15:25:10.239080Z"
-creator: insta@0.6.3
-source: debuginfo/tests/test_objects.rs
+source: symbolic-debuginfo/tests/test_objects.rs
 expression: "FunctionsDebug(&functions[..10], 0)"
 ---
-
 > 0x1000: google_breakpad::CrashGenerationClient::RequestDump(_EXCEPTION_POINTERS *,MDRawAssertionInfo *) (0x114)
   0x1000: crash_generation_client.cc:323 (c:\projects\breakpad-tools\deps\breakpad\src\client\windows\crash_generation)
   0x1011: crash_generation_client.cc:324 (c:\projects\breakpad-tools\deps\breakpad\src\client\windows\crash_generation)
@@ -132,4 +129,3 @@ expression: "FunctionsDebug(&functions[..10], 0)"
   0x1727: exception_handler.cc:289 (c:\projects\breakpad-tools\deps\breakpad\src\client\windows\handler)
   0x1741: exception_handler.cc:291 (c:\projects\breakpad-tools\deps\breakpad\src\client\windows\handler)
   0x174c: exception_handler.cc:293 (c:\projects\breakpad-tools\deps\breakpad\src\client\windows\handler)
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_functions_mac_with_inlines.snap b/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_functions_mac_with_inlines.snap
index 54e3ccdab..9ba47d342 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_functions_mac_with_inlines.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_functions_mac_with_inlines.snap
@@ -1,9 +1,7 @@
 ---
 source: symbolic-debuginfo/tests/test_objects.rs
-assertion_line: 150
 expression: "FunctionsDebug(&functions[..10], 0)"
 ---
-
 > 0xd20: google_breakpad::MinidumpFileWriter::MinidumpFileWriter() (0x1a)
   0xd20: minidump_file_writer.cc:93 (/Users/travis/build/getsentry/breakpad-tools/deps/breakpad/src/client)
   0xd26: minidump_file_writer.cc:94 (/Users/travis/build/getsentry/breakpad-tools/deps/breakpad/src/client)
@@ -163,4 +161,3 @@ expression: "FunctionsDebug(&functions[..10], 0)"
 
 > 0x1140: google_breakpad::MinidumpFileWriter::WriteString(wchar_t const*, unsigned int, MDLocationDescriptor*) (0x5)
   0x1140: minidump_file_writer.cc:245 (/Users/travis/build/getsentry/breakpad-tools/deps/breakpad/src/client)
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_symbols.snap b/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_symbols.snap
index fb743ded4..a20b09e98 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_symbols.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__breakpad_symbols.snap
@@ -1,8 +1,6 @@
 ---
-created: "2019-02-20T11:25:23.767168Z"
-creator: insta@0.6.3
-source: debuginfo/tests/test_objects.rs
-expression: SymbolDebug(&symbols)
+source: symbolic-debuginfo/tests/test_objects.rs
+expression: SymbolsDebug(&symbols)
 ---
             3726 __CxxFrameHandler3
             372c __std_exception_copy
@@ -39,4 +37,3 @@ expression: SymbolDebug(&symbols)
             37e6 terminate
             37ec IsProcessorFeaturePresent
             37f2 memcpy
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__elf_files.snap b/symbolic-debuginfo/tests/snapshots/test_objects__elf_files.snap
index 34225960f..6b06c6990 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__elf_files.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__elf_files.snap
@@ -1,7 +1,5 @@
 ---
-created: "2019-06-28T08:34:30.750035Z"
-creator: insta@0.8.1
-source: debuginfo/tests/test_objects.rs
+source: symbolic-debuginfo/tests/test_objects.rs
 expression: "FilesDebug(&files[..10])"
 ---
 /work/linux/main.cpp
@@ -14,4 +12,3 @@ expression: "FilesDebug(&files[..10])"
 /usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h
 /usr/include/x86_64-linux-gnu/bits/types.h
 /usr/include/stdio.h
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__elf_functions.snap b/symbolic-debuginfo/tests/snapshots/test_objects__elf_functions.snap
index 6e5c3f7b9..3119318ba 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__elf_functions.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__elf_functions.snap
@@ -2,7 +2,6 @@
 source: symbolic-debuginfo/tests/test_objects.rs
 expression: "FunctionsDebug(&functions[..10], 0)"
 ---
-
 > 0x1ec0: _ZN12_GLOBAL__N_18callbackERKN15google_breakpad18MinidumpDescriptorEPvb (0x3b)
   0x1ec0: main.cpp:9 (../linux)
   0x1ec2: main.cpp:8 (../linux)
@@ -965,4 +964,3 @@ expression: "FunctionsDebug(&functions[..10], 0)"
 
   > 0x2dae: InstallDefaultHandler (0xc)
     0x2dae: exception_handler.cc:199 (../deps/breakpad/src/client/linux/handler)
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__elf_symbols.snap b/symbolic-debuginfo/tests/snapshots/test_objects__elf_symbols.snap
index 2e0c5f3ea..a7bb1d236 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__elf_symbols.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__elf_symbols.snap
@@ -1,7 +1,5 @@
 ---
-created: "2019-02-27T13:05:25.490529Z"
-creator: insta@0.6.3
-source: debuginfo/tests/test_objects.rs
+source: symbolic-debuginfo/tests/test_objects.rs
 expression: SymbolsDebug(&symbols)
 ---
             1558 _init
@@ -42,7 +40,7 @@ expression: SymbolsDebug(&symbols)
             3670 _ZN15google_breakpad16ExceptionHandlerC1ERKNS_18MinidumpDescriptorEPFbPvEPFbS3_S4_bES4_bi
             3a10 _ZN15google_breakpad16ExceptionHandler13WriteMinidumpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPFbRKNS_18MinidumpDescriptorEPvbESC_
             3cb0 _ZNSt6vectorIPN15google_breakpad16ExceptionHandlerESaIS2_EE19_M_emplace_back_auxIIS2_EEEvDpOT_
-            3da0 _ZN15google_breakpad18MinidumpDescriptorC1ERKS0_
+            3da0 _ZN15google_breakpad18MinidumpDescriptorC2ERKS0_
             3f20 _ZN15google_breakpad18MinidumpDescriptor10UpdatePathEv
             42f0 _ZN15google_breakpad18MinidumpDescriptoraSERKS0_
             43c0 _ZN6logger5writeEPKcm
@@ -50,7 +48,7 @@ expression: SymbolsDebug(&symbols)
             6e10 _ZNSt6vectorIhN15google_breakpad16PageStdAllocatorIhEEE15_M_range_insertIPKhEEvN9__gnu_cxx17__normal_iteratorIPhS3_EET_SB_St20forward_iterator_tag
             71f0 _ZN15google_breakpad11LinuxDumper8LateInitEv
             7200 _ZN15google_breakpad11LinuxDumper17EnumerateMappingsEv
-            7ac0 _ZN15google_breakpad11LinuxDumperC1EiPKc
+            7ac0 _ZN15google_breakpad11LinuxDumperC2EiPKc
             8300 _ZN15google_breakpad11LinuxDumperD2Ev
             8370 _ZN15google_breakpad11LinuxDumperD0Ev
             8390 _ZNK15google_breakpad11LinuxDumper20GetCrashSignalStringEv
@@ -71,14 +69,14 @@ expression: SymbolsDebug(&symbols)
             94a0 _ZNK15google_breakpad17LinuxPtraceDumper12IsPostMortemEv
             94b0 _ZN15google_breakpad17LinuxPtraceDumper15CopyFromProcessEPviPKvm
             9640 _ZN15google_breakpad17LinuxPtraceDumper13ThreadsResumeEv
-            9700 _ZNK15google_breakpad17LinuxPtraceDumper13BuildProcPathEPciPKc
+            9700 _ZNK15google_breakpad17LinuxPtraceDumper13BuildProcPathEPciPKc.localalias.19
             97c0 _ZN15google_breakpad17LinuxPtraceDumper16EnumerateThreadsEv
             9e50 _ZN15google_breakpad17LinuxPtraceDumperC1Ei
             9e80 _ZN15google_breakpad17LinuxPtraceDumper15ReadRegisterSetEPNS_10ThreadInfoEi
             9f70 _ZN15google_breakpad17LinuxPtraceDumper13ReadRegistersEPNS_10ThreadInfoEi
             a050 _ZN15google_breakpad17LinuxPtraceDumper20GetThreadInfoByIndexEmPNS_10ThreadInfoE
             a690 _ZN15google_breakpad17LinuxPtraceDumper14ThreadsSuspendEv
-            a8f0 _ZN15google_breakpad17LinuxPtraceDumperD1Ev
+            a8f0 _ZN15google_breakpad17LinuxPtraceDumperD2Ev
             a910 _ZN15google_breakpad17LinuxPtraceDumperD0Ev
             a930 _ZNSt6vectorIiN15google_breakpad16PageStdAllocatorIiEEE17_M_default_appendEm
             abc0 _ZN12_GLOBAL__N_114MinidumpWriter21WriteThreadListStreamEP14MDRawDirectory.constprop.105
@@ -120,7 +118,7 @@ expression: SymbolsDebug(&symbols)
            11220 _ZN15google_breakpad8ElfClassEPKv
            11230 _ZN15google_breakpad14FindElfSectionEPKvPKcjPS1_Pm
            116a0 _ZN15google_breakpad15FindElfSegmentsEPKvjPNS_15wasteful_vectorINS_10ElfSegmentEEE
-           11990 _ZNSt6vectorIN15google_breakpad10ElfSegmentENS0_16PageStdAllocatorIS1_EEE19_M_emplace_back_auxIIRKS1_EEEvDpOT_
+           11990 _ZNSt6vectorIN15google_breakpad10ElfSegmentENS0_16PageStdAllocatorIS1_EEE19_M_emplace_back_auxIJRKS1_EEEvDpOT_
            11be0 _ZN15google_breakpad6FileIDC2EPKc
            11cc0 _ZN15google_breakpad6FileID29ConvertIdentifierToUUIDStringB5cxx11ERKNS_15wasteful_vectorIhEE
            11e70 _ZN15google_breakpad6FileID25ConvertIdentifierToStringB5cxx11ERKNS_15wasteful_vectorIhEE
@@ -146,11 +144,11 @@ expression: SymbolsDebug(&symbols)
            13160 my_isspace
            13210 _ZN15google_breakpad16MemoryMappedFileC2Ev
            13220 _ZN15google_breakpad16MemoryMappedFile5UnmapEv
-           13270 _ZN15google_breakpad16MemoryMappedFileD2Ev
+           13270 _ZN15google_breakpad16MemoryMappedFileD1Ev
            13280 _ZN15google_breakpad16MemoryMappedFile3MapEPKcm
-           13430 _ZN15google_breakpad16MemoryMappedFileC1EPKcm
+           13430 _ZN15google_breakpad16MemoryMappedFileC2EPKcm
            13450 _ZN15google_breakpad12SafeReadLinkEPKcPcm
-           13490 _ZN15google_breakpad12_GLOBAL__N_125CrashGenerationClientImplD1Ev
+           13490 _ZN15google_breakpad12_GLOBAL__N_125CrashGenerationClientImplD2Ev
            134a0 _ZN15google_breakpad12_GLOBAL__N_125CrashGenerationClientImpl11RequestDumpEPKvm
            136c0 _ZN15google_breakpad12_GLOBAL__N_125CrashGenerationClientImplD0Ev
            136d0 _ZN15google_breakpad21CrashGenerationClient9TryCreateEi
@@ -171,4 +169,3 @@ expression: SymbolsDebug(&symbols)
            14c30 __libc_csu_init
            14ca0 __libc_csu_fini
            14ca4 _fini
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__mach_files.snap b/symbolic-debuginfo/tests/snapshots/test_objects__mach_files.snap
index a3e6c277c..5b221a9fa 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__mach_files.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__mach_files.snap
@@ -1,7 +1,5 @@
 ---
-created: "2019-06-28T08:34:30.763613Z"
-creator: insta@0.8.1
-source: debuginfo/tests/test_objects.rs
+source: symbolic-debuginfo/tests/test_objects.rs
 expression: "FilesDebug(&files[..10])"
 ---
 /Users/travis/build/getsentry/breakpad-tools/deps/breakpad/src/client/minidump_file_writer.h
@@ -14,4 +12,3 @@ expression: "FilesDebug(&files[..10])"
 /usr/include/_types/_uint16_t.h
 /usr/include/sys/_types.h
 /usr/include/sys/_types/_off_t.h
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__mach_functions.snap b/symbolic-debuginfo/tests/snapshots/test_objects__mach_functions.snap
index f490e606f..e88834f17 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__mach_functions.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__mach_functions.snap
@@ -1,9 +1,7 @@
 ---
 source: symbolic-debuginfo/tests/test_objects.rs
-assertion_line: 396
 expression: "FunctionsDebug(&functions[..10], 0)"
 ---
-
 > 0xd20: _ZN15google_breakpad18MinidumpFileWriterC2Ev (0x1a)
   0xd20: minidump_file_writer.cc:93 (../deps/breakpad/src/client)
   0xd26: minidump_file_writer.cc:94 (../deps/breakpad/src/client)
@@ -188,4 +186,3 @@ expression: "FunctionsDebug(&functions[..10], 0)"
 
 > 0x1140: _ZN15google_breakpad18MinidumpFileWriter11WriteStringEPKwjP20MDLocationDescriptor (0x5)
   0x1140: minidump_file_writer.cc:245 (../deps/breakpad/src/client)
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__mach_symbols.snap b/symbolic-debuginfo/tests/snapshots/test_objects__mach_symbols.snap
index d345cc0eb..e4b8b2b0f 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__mach_symbols.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__mach_symbols.snap
@@ -1,8 +1,6 @@
 ---
-created: "2019-02-20T12:28:37.426989Z"
-creator: insta@0.6.3
-source: debuginfo/tests/test_objects.rs
-expression: SymbolDebug(&symbols)
+source: symbolic-debuginfo/tests/test_objects.rs
+expression: SymbolsDebug(&symbols)
 ---
                0 _mh_execute_header
              d20 _ZN15google_breakpad18MinidumpFileWriterC2Ev
@@ -199,4 +197,3 @@ expression: SymbolDebug(&symbols)
             db50 _ZN15google_breakpad14MachPortSender11SendMessageERNS_15MachSendMessageEj
             dba0 main
             dc70 _ZN12_GLOBAL__N_18callbackEPKcS1_Pvb
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__pdb_files.snap b/symbolic-debuginfo/tests/snapshots/test_objects__pdb_files.snap
index 7a28c92be..44a7eb330 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__pdb_files.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__pdb_files.snap
@@ -1,7 +1,5 @@
 ---
-created: "2019-06-28T08:20:37.446264Z"
-creator: insta@0.8.1
-source: debuginfo/tests/test_objects.rs
+source: symbolic-debuginfo/tests/test_objects.rs
 expression: "FilesDebug(&files[..10])"
 ---
 c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.13.26128\include\system_error
@@ -14,4 +12,3 @@ c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.1
 c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.13.26128\include\xstring
 c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.13.26128\include\cstdlib
 c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.13.26128\include\xmemory0
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__pdb_functions.snap b/symbolic-debuginfo/tests/snapshots/test_objects__pdb_functions.snap
index b9322d65f..3b3bc651c 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__pdb_functions.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__pdb_functions.snap
@@ -1,9 +1,7 @@
 ---
 source: symbolic-debuginfo/tests/test_objects.rs
-assertion_line: 524
 expression: "FunctionsDebug(&functions[..10], 0)"
 ---
-
 > 0x1120: std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >::~basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >() (0x54)
   0x1120: xstring:2424 (c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.13.26128\include)
   0x1123: xstring:2425 (c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.13.26128\include)
@@ -469,4 +467,3 @@ expression: "FunctionsDebug(&functions[..10], 0)"
 > 0x2690: google_breakpad::scoped_ptr<google_breakpad::CrashGenerationClient>::~scoped_ptr<google_breakpad::CrashGenerationClient>() (0xd)
   0x2690: scoped_ptr.h:98 (c:\projects\breakpad-tools\deps\breakpad\src\common)
   0x269c: scoped_ptr.h:99 (c:\projects\breakpad-tools\deps\breakpad\src\common)
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__pdb_symbols.snap b/symbolic-debuginfo/tests/snapshots/test_objects__pdb_symbols.snap
index d5e9f6495..03a3a0704 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__pdb_symbols.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__pdb_symbols.snap
@@ -48,7 +48,7 @@ expression: SymbolsDebug(&symbols)
             2e72 ??0bad_array_new_length@std@@QAE@XZ
             2e8a ??0exception@std@@QAE@ABV01@@Z
             2eb6 ??1bad_alloc@std@@UAE@XZ
-            2ec7 ??_Eexception@std@@UAEPAXI@Z
+            2ec7 ??_Gexception@std@@UAEPAXI@Z
             2ef4 ?__scrt_throw_std_bad_alloc@@YAXXZ
             2f11 ?__scrt_throw_std_bad_array_new_length@@YAXXZ
             2f2e ?what@exception@std@@UBEPBDXZ
@@ -61,11 +61,11 @@ expression: SymbolsDebug(&symbols)
             3166 __onexit
             31a1 _atexit
             3205 ___security_init_cookie
-            3250 __matherr
+            3250 __get_startup_commit_mode
             3253 __get_startup_argv_mode
             3257 __get_startup_file_mode
             325d ?__scrt_initialize_type_info@@YAXXZ
-            3269 ___vcrt_uninitialize
+            3269 __should_initialize_environment
             326c __initialize_default_precision
             328d @_guard_check_icall_nop@4
             328e ___local_stdio_scanf_options
@@ -122,4 +122,3 @@ expression: SymbolsDebug(&symbols)
             37e6 _terminate
             37ec _IsProcessorFeaturePresent@4
             37f2 _memcpy
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__pe_dwarf_files.snap b/symbolic-debuginfo/tests/snapshots/test_objects__pe_dwarf_files.snap
index 1fc613ad4..52a8d9f6d 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__pe_dwarf_files.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__pe_dwarf_files.snap
@@ -12,4 +12,3 @@ expression: "FilesDebug(&files[..10])"
 /mxe/usr/x86_64-w64-mingw32.static/include/stdlib.h
 /mxe/usr/x86_64-w64-mingw32.static/include/errhandlingapi.h
 /mxe/usr/x86_64-w64-mingw32.static/include/processthreadsapi.h
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__pe_dwarf_functions.snap b/symbolic-debuginfo/tests/snapshots/test_objects__pe_dwarf_functions.snap
index 1ae2b97d5..35d31fe47 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__pe_dwarf_functions.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__pe_dwarf_functions.snap
@@ -2,7 +2,6 @@
 source: symbolic-debuginfo/tests/test_objects.rs
 expression: "FunctionsDebug(&functions[..10], 0)"
 ---
-
 > 0x14f0: atexit (0x14)
   0x14f0: crtexe.c:418 (/mxe/tmp-gcc-x86_64-w64-mingw32.static/gcc-11.3.0.build_/mingw-w64-v10.0.0/mingw-w64-crt/crt)
   0x14f4: crtexe.c:419 (/mxe/tmp-gcc-x86_64-w64-mingw32.static/gcc-11.3.0.build_/mingw-w64-v10.0.0/mingw-w64-crt/crt)
@@ -220,4 +219,3 @@ expression: "FunctionsDebug(&functions[..10], 0)"
   0x165a: gccmain.c:60 (/mxe/tmp-gcc-x86_64-w64-mingw32.static/gcc-11.3.0.build_/mingw-w64-v10.0.0/mingw-w64-crt/crt)
   0x1660: gccmain.c:57 (/mxe/tmp-gcc-x86_64-w64-mingw32.static/gcc-11.3.0.build_/mingw-w64-v10.0.0/mingw-w64-crt/crt)
   0x166a: gccmain.c:58 (/mxe/tmp-gcc-x86_64-w64-mingw32.static/gcc-11.3.0.build_/mingw-w64-v10.0.0/mingw-w64-crt/crt)
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__ppdb_files.snap b/symbolic-debuginfo/tests/snapshots/test_objects__ppdb_files.snap
index c5e27ef8c..fa4abdf02 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__ppdb_files.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__ppdb_files.snap
@@ -1,10 +1,8 @@
 ---
 source: symbolic-debuginfo/tests/test_objects.rs
-assertion_line: 656
 expression: FilesDebug(&files)
 ---
 /Users/swatinem/Coding/sentry-dotnet/samples/foo/Program.cs
 /Users/swatinem/Coding/sentry-dotnet/samples/foo/obj/Debug/net6.0/foo.GlobalUsings.g.cs
 /Users/swatinem/Coding/sentry-dotnet/samples/foo/obj/Debug/net6.0/.NETCoreApp,Version=v6.0.AssemblyAttributes.cs
 /Users/swatinem/Coding/sentry-dotnet/samples/foo/obj/Debug/net6.0/foo.AssemblyInfo.cs
-
diff --git a/symbolic-debuginfo/tests/snapshots/test_objects__wasm_symbols.snap b/symbolic-debuginfo/tests/snapshots/test_objects__wasm_symbols.snap
index 3208bb17a..580378ecf 100644
--- a/symbolic-debuginfo/tests/snapshots/test_objects__wasm_symbols.snap
+++ b/symbolic-debuginfo/tests/snapshots/test_objects__wasm_symbols.snap
@@ -1,7 +1,5 @@
 ---
 source: symbolic-debuginfo/tests/test_objects.rs
 expression: SymbolsDebug(&symbols)
-
 ---
               8b internal_func
-
diff --git a/symbolic-debuginfo/tests/test_objects.rs b/symbolic-debuginfo/tests/test_objects.rs
index 6372f0a18..861b4e871 100644
--- a/symbolic-debuginfo/tests/test_objects.rs
+++ b/symbolic-debuginfo/tests/test_objects.rs
@@ -128,23 +128,23 @@ fn test_breakpad() -> Result<(), Error> {
     let object = Object::parse(&view)?;
 
     insta::assert_debug_snapshot!(object, @r#"
-   ⋮Breakpad(
-   ⋮    BreakpadObject {
-   ⋮        code_id: Some(
-   ⋮            CodeId(5ab380779000),
-   ⋮        ),
-   ⋮        debug_id: DebugId {
-   ⋮            uuid: "3249d99d-0c40-4931-8610-f4e4fb0b6936",
-   ⋮            appendix: 1,
-   ⋮        },
-   ⋮        arch: X86,
-   ⋮        name: "crash.pdb",
-   ⋮        has_symbols: true,
-   ⋮        has_debug_info: true,
-   ⋮        has_unwind_info: true,
-   ⋮        is_malformed: false,
-   ⋮    },
-   ⋮)
+    Breakpad(
+        BreakpadObject {
+            code_id: Some(
+                CodeId(5ab380779000),
+            ),
+            debug_id: DebugId {
+                uuid: "3249d99d-0c40-4931-8610-f4e4fb0b6936",
+                appendix: 1,
+            },
+            arch: X86,
+            name: "crash.pdb",
+            has_symbols: true,
+            has_debug_info: true,
+            has_unwind_info: true,
+            is_malformed: false,
+        },
+    )
     "#);
 
     Ok(())
@@ -209,24 +209,24 @@ fn test_elf_executable() -> Result<(), Error> {
     let object = Object::parse(&view)?;
 
     insta::assert_debug_snapshot!(object, @r#"
-   ⋮Elf(
-   ⋮    ElfObject {
-   ⋮        code_id: Some(
-   ⋮            CodeId(f1c3bcc0279865fe3058404b2831d9e64135386c),
-   ⋮        ),
-   ⋮        debug_id: DebugId {
-   ⋮            uuid: "c0bcc3f1-9827-fe65-3058-404b2831d9e6",
-   ⋮            appendix: 0,
-   ⋮        },
-   ⋮        arch: Amd64,
-   ⋮        kind: Executable,
-   ⋮        load_address: 0x400000,
-   ⋮        has_symbols: true,
-   ⋮        has_debug_info: false,
-   ⋮        has_unwind_info: true,
-   ⋮        is_malformed: false,
-   ⋮    },
-   ⋮)
+    Elf(
+        ElfObject {
+            code_id: Some(
+                CodeId(f1c3bcc0279865fe3058404b2831d9e64135386c),
+            ),
+            debug_id: DebugId {
+                uuid: "c0bcc3f1-9827-fe65-3058-404b2831d9e6",
+                appendix: 0,
+            },
+            arch: Amd64,
+            kind: Executable,
+            load_address: 0x400000,
+            has_symbols: true,
+            has_debug_info: false,
+            has_unwind_info: true,
+            is_malformed: false,
+        },
+    )
     "#);
 
     Ok(())
@@ -238,24 +238,53 @@ fn test_elf_debug() -> Result<(), Error> {
     let object = Object::parse(&view)?;
 
     insta::assert_debug_snapshot!(object, @r#"
-   ⋮Elf(
-   ⋮    ElfObject {
-   ⋮        code_id: Some(
-   ⋮            CodeId(f1c3bcc0279865fe3058404b2831d9e64135386c),
-   ⋮        ),
-   ⋮        debug_id: DebugId {
-   ⋮            uuid: "c0bcc3f1-9827-fe65-3058-404b2831d9e6",
-   ⋮            appendix: 0,
-   ⋮        },
-   ⋮        arch: Amd64,
-   ⋮        kind: Debug,
-   ⋮        load_address: 0x400000,
-   ⋮        has_symbols: true,
-   ⋮        has_debug_info: true,
-   ⋮        has_unwind_info: false,
-   ⋮        is_malformed: false,
-   ⋮    },
-   ⋮)
+    Elf(
+        ElfObject {
+            code_id: Some(
+                CodeId(f1c3bcc0279865fe3058404b2831d9e64135386c),
+            ),
+            debug_id: DebugId {
+                uuid: "c0bcc3f1-9827-fe65-3058-404b2831d9e6",
+                appendix: 0,
+            },
+            arch: Amd64,
+            kind: Debug,
+            load_address: 0x400000,
+            has_symbols: true,
+            has_debug_info: true,
+            has_unwind_info: false,
+            is_malformed: false,
+        },
+    )
+    "#);
+
+    Ok(())
+}
+
+#[test]
+fn test_elf_dynsyms() -> Result<(), Error> {
+    let view = ByteView::open(fixture("linux/dynsyms_only"))?;
+    let object = Object::parse(&view)?;
+
+    insta::assert_debug_snapshot!(object, @r#"
+    Elf(
+        ElfObject {
+            code_id: Some(
+                CodeId(b931c4fbd186e551bb617b3807d594b9064f5cac),
+            ),
+            debug_id: DebugId {
+                uuid: "fbc431b9-86d1-51e5-bb61-7b3807d594b9",
+                appendix: 0,
+            },
+            arch: Amd64,
+            kind: Debug,
+            load_address: 0x0,
+            has_symbols: true,
+            has_debug_info: false,
+            has_unwind_info: false,
+            is_malformed: false,
+        },
+    )
     "#);
 
     Ok(())
@@ -269,6 +298,19 @@ fn test_elf_symbols() -> Result<(), Error> {
     let symbols = object.symbol_map();
     insta::assert_debug_snapshot!("elf_symbols", SymbolsDebug(&symbols));
 
+    let view = ByteView::open(fixture("linux/dynsyms_only"))?;
+    let object = Object::parse(&view)?;
+
+    let symbols = object.symbol_map();
+    insta::assert_debug_snapshot!(SymbolsDebug(&symbols), @r"
+    690 __vdso_gettimeofday
+    9e0 __vdso_time
+    a10 clock_gettime
+    e30 clock_getres
+    e90 __vdso_getcpu
+    ec0 __vdso_sgx_enter_enclave
+    ");
+
     Ok(())
 }
 
@@ -388,24 +430,24 @@ fn test_mach_executable() -> Result<(), Error> {
     let object = Object::parse(&view)?;
 
     insta::assert_debug_snapshot!(object, @r#"
-   ⋮MachO(
-   ⋮    MachObject {
-   ⋮        code_id: Some(
-   ⋮            CodeId(67e9247c814e392ba027dbde6748fcbf),
-   ⋮        ),
-   ⋮        debug_id: DebugId {
-   ⋮            uuid: "67e9247c-814e-392b-a027-dbde6748fcbf",
-   ⋮            appendix: 0,
-   ⋮        },
-   ⋮        arch: Amd64,
-   ⋮        kind: Executable,
-   ⋮        load_address: 0x100000000,
-   ⋮        has_symbols: true,
-   ⋮        has_debug_info: false,
-   ⋮        has_unwind_info: true,
-   ⋮        is_malformed: false,
-   ⋮    },
-   ⋮)
+    MachO(
+        MachObject {
+            code_id: Some(
+                CodeId(67e9247c814e392ba027dbde6748fcbf),
+            ),
+            debug_id: DebugId {
+                uuid: "67e9247c-814e-392b-a027-dbde6748fcbf",
+                appendix: 0,
+            },
+            arch: Amd64,
+            kind: Executable,
+            load_address: 0x100000000,
+            has_symbols: true,
+            has_debug_info: false,
+            has_unwind_info: true,
+            is_malformed: false,
+        },
+    )
     "#);
 
     Ok(())
@@ -417,24 +459,24 @@ fn test_mach_dsym() -> Result<(), Error> {
     let object = Object::parse(&view)?;
 
     insta::assert_debug_snapshot!(object, @r#"
-   ⋮MachO(
-   ⋮    MachObject {
-   ⋮        code_id: Some(
-   ⋮            CodeId(67e9247c814e392ba027dbde6748fcbf),
-   ⋮        ),
-   ⋮        debug_id: DebugId {
-   ⋮            uuid: "67e9247c-814e-392b-a027-dbde6748fcbf",
-   ⋮            appendix: 0,
-   ⋮        },
-   ⋮        arch: Amd64,
-   ⋮        kind: Debug,
-   ⋮        load_address: 0x100000000,
-   ⋮        has_symbols: true,
-   ⋮        has_debug_info: true,
-   ⋮        has_unwind_info: false,
-   ⋮        is_malformed: false,
-   ⋮    },
-   ⋮)
+    MachO(
+        MachObject {
+            code_id: Some(
+                CodeId(67e9247c814e392ba027dbde6748fcbf),
+            ),
+            debug_id: DebugId {
+                uuid: "67e9247c-814e-392b-a027-dbde6748fcbf",
+                appendix: 0,
+            },
+            arch: Amd64,
+            kind: Debug,
+            load_address: 0x100000000,
+            has_symbols: true,
+            has_debug_info: true,
+            has_unwind_info: false,
+            is_malformed: false,
+        },
+    )
     "#);
 
     Ok(())
@@ -483,27 +525,27 @@ fn test_pe_32() -> Result<(), Error> {
     let object = Object::parse(&view)?;
 
     insta::assert_debug_snapshot!(object, @r#"
-   ⋮Pe(
-   ⋮    PeObject {
-   ⋮        code_id: Some(
-   ⋮            CodeId(5ab380779000),
-   ⋮        ),
-   ⋮        debug_id: DebugId {
-   ⋮            uuid: "3249d99d-0c40-4931-8610-f4e4fb0b6936",
-   ⋮            appendix: 1,
-   ⋮        },
-   ⋮        debug_file_name: Some(
-   ⋮            "C:\\projects\\breakpad-tools\\windows\\Release\\crash.pdb",
-   ⋮        ),
-   ⋮        arch: X86,
-   ⋮        kind: Executable,
-   ⋮        load_address: 0x400000,
-   ⋮        has_symbols: false,
-   ⋮        has_debug_info: false,
-   ⋮        has_unwind_info: false,
-   ⋮        is_malformed: false,
-   ⋮    },
-   ⋮)
+    Pe(
+        PeObject {
+            code_id: Some(
+                CodeId(5ab380779000),
+            ),
+            debug_id: DebugId {
+                uuid: "3249d99d-0c40-4931-8610-f4e4fb0b6936",
+                appendix: 1,
+            },
+            debug_file_name: Some(
+                "C:\\projects\\breakpad-tools\\windows\\Release\\crash.pdb",
+            ),
+            arch: X86,
+            kind: Executable,
+            load_address: 0x400000,
+            has_symbols: false,
+            has_debug_info: false,
+            has_unwind_info: false,
+            is_malformed: false,
+        },
+    )
     "#);
 
     Ok(())
@@ -515,27 +557,27 @@ fn test_pe_64() -> Result<(), Error> {
     let object = Object::parse(&view)?;
 
     insta::assert_debug_snapshot!(object, @r#"
-   ⋮Pe(
-   ⋮    PeObject {
-   ⋮        code_id: Some(
-   ⋮            CodeId(5c9e09599000),
-   ⋮        ),
-   ⋮        debug_id: DebugId {
-   ⋮            uuid: "f535c5fb-2ae8-4bb8-aa20-6c30be566c5a",
-   ⋮            appendix: 1,
-   ⋮        },
-   ⋮        debug_file_name: Some(
-   ⋮            "C:\\Users\\sentry\\source\\repos\\CrashWithException\\x64\\Release\\CrashWithException.pdb",
-   ⋮        ),
-   ⋮        arch: Amd64,
-   ⋮        kind: Executable,
-   ⋮        load_address: 0x140000000,
-   ⋮        has_symbols: false,
-   ⋮        has_debug_info: false,
-   ⋮        has_unwind_info: true,
-   ⋮        is_malformed: false,
-   ⋮    },
-   ⋮)
+    Pe(
+        PeObject {
+            code_id: Some(
+                CodeId(5c9e09599000),
+            ),
+            debug_id: DebugId {
+                uuid: "f535c5fb-2ae8-4bb8-aa20-6c30be566c5a",
+                appendix: 1,
+            },
+            debug_file_name: Some(
+                "C:\\Users\\sentry\\source\\repos\\CrashWithException\\x64\\Release\\CrashWithException.pdb",
+            ),
+            arch: Amd64,
+            kind: Executable,
+            load_address: 0x140000000,
+            has_symbols: false,
+            has_debug_info: false,
+            has_unwind_info: true,
+            is_malformed: false,
+        },
+    )
     "#);
 
     Ok(())
@@ -613,20 +655,20 @@ fn test_pdb() -> Result<(), Error> {
     let object = Object::parse(&view)?;
 
     insta::assert_debug_snapshot!(object, @r#"
-   ⋮Pdb(
-   ⋮    PdbObject {
-   ⋮        debug_id: DebugId {
-   ⋮            uuid: "3249d99d-0c40-4931-8610-f4e4fb0b6936",
-   ⋮            appendix: 1,
-   ⋮        },
-   ⋮        arch: X86,
-   ⋮        load_address: 0x0,
-   ⋮        has_symbols: true,
-   ⋮        has_debug_info: true,
-   ⋮        has_unwind_info: true,
-   ⋮        is_malformed: false,
-   ⋮    },
-   ⋮)
+    Pdb(
+        PdbObject {
+            debug_id: DebugId {
+                uuid: "3249d99d-0c40-4931-8610-f4e4fb0b6936",
+                appendix: 1,
+            },
+            arch: X86,
+            load_address: 0x0,
+            has_symbols: true,
+            has_debug_info: true,
+            has_unwind_info: true,
+            is_malformed: false,
+        },
+    )
     "#);
 
     Ok(())
@@ -701,29 +743,29 @@ fn test_ppdb() -> Result<(), Error> {
     let object = Object::parse(&view)?;
 
     insta::assert_debug_snapshot!(object, @r#"
-    ⋮PortablePdb(
-    ⋮    PortablePdbObject {
-    ⋮        portable_pdb: PortablePdb {
-    ⋮            header: Header {
-    ⋮                signature: 1112167234,
-    ⋮                major_version: 1,
-    ⋮                minor_version: 1,
-    ⋮                version_length: 12,
-    ⋮            },
-    ⋮            version_string: "PDB v1.0",
-    ⋮            header2: HeaderPart2 {
-    ⋮                flags: 0,
-    ⋮                streams: 6,
-    ⋮            },
-    ⋮            has_pdb_stream: true,
-    ⋮            has_table_stream: true,
-    ⋮            has_string_stream: true,
-    ⋮            has_us_stream: true,
-    ⋮            has_blob_stream: true,
-    ⋮            has_guid_stream: true,
-    ⋮        },
-    ⋮    },
-    ⋮)
+    PortablePdb(
+        PortablePdbObject {
+            portable_pdb: PortablePdb {
+                header: Header {
+                    signature: 1112167234,
+                    major_version: 1,
+                    minor_version: 1,
+                    version_length: 12,
+                },
+                version_string: "PDB v1.0",
+                header2: HeaderPart2 {
+                    flags: 0,
+                    streams: 6,
+                },
+                has_pdb_stream: true,
+                has_table_stream: true,
+                has_string_stream: true,
+                has_us_stream: true,
+                has_blob_stream: true,
+                has_guid_stream: true,
+            },
+        },
+    )
     "#);
 
     Ok(())
diff --git a/symbolic-debuginfo/tests/test_pdb_srcsrv.rs b/symbolic-debuginfo/tests/test_pdb_srcsrv.rs
new file mode 100644
index 000000000..a5aae549b
--- /dev/null
+++ b/symbolic-debuginfo/tests/test_pdb_srcsrv.rs
@@ -0,0 +1,29 @@
+use symbolic_common::ByteView;
+use symbolic_debuginfo::pdb::PdbObject;
+use symbolic_testutils::fixture;
+
+type Error = Box<dyn std::error::Error>;
+
+#[test]
+fn test_pdb_srcsrv_vcs_name() -> Result<(), Error> {
+    let view = ByteView::open(fixture("windows/crash_with_srcsrv.pdb"))?;
+    let pdb = PdbObject::parse(&view)?;
+
+    // This PDB file contains Perforce SRCSRV information
+    let vcs_name = pdb.srcsrv_vcs_name();
+    assert_eq!(vcs_name, Some("Perforce".to_string()));
+
+    Ok(())
+}
+
+#[test]
+fn test_pdb_without_srcsrv() -> Result<(), Error> {
+    let view = ByteView::open(fixture("windows/crash.pdb"))?;
+    let pdb = PdbObject::parse(&view)?;
+
+    // This PDB file does not contain SRCSRV information
+    let vcs_name = pdb.srcsrv_vcs_name();
+    assert_eq!(vcs_name, None);
+
+    Ok(())
+}
diff --git a/symbolic-demangle/Cargo.toml b/symbolic-demangle/Cargo.toml
index 8f8bc44c1..50be35d54 100644
--- a/symbolic-demangle/Cargo.toml
+++ b/symbolic-demangle/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-demangle"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 authors = [
     "Armin Ronacher <armin.ronacher@active-4.com>",
@@ -14,7 +14,8 @@ description = """
 A library to demangle symbols from various languages and compilers.
 """
 build = "build.rs"
-edition = "2021"
+edition.workspace = true
+rust-version.workspace = true
 
 exclude = ["tests/**/*"]
 
@@ -32,7 +33,7 @@ swift = ["cc"]
 cpp_demangle = { workspace = true, optional = true }
 msvc-demangler = { workspace = true, optional = true }
 rustc-demangle = { workspace = true, optional = true }
-symbolic-common = { version = "12.9.2-dd", path = "../symbolic-common" }
+symbolic-common = { version = "12.17.0-dd", path = "../symbolic-common" }
 
 [build-dependencies]
 cc = { workspace = true, optional = true }
diff --git a/symbolic-demangle/build.rs b/symbolic-demangle/build.rs
index 4ce782eb0..1ec58b0a7 100644
--- a/symbolic-demangle/build.rs
+++ b/symbolic-demangle/build.rs
@@ -3,20 +3,25 @@ fn main() {
     {
         cc::Build::new()
             .cpp(true)
+            .std("c++17")
             .files(&[
                 "src/swiftdemangle.cpp",
-                "vendor/swift/lib/Demangling/Demangler.cpp",
                 "vendor/swift/lib/Demangling/Context.cpp",
+                "vendor/swift/lib/Demangling/CrashReporter.cpp",
+                "vendor/swift/lib/Demangling/Demangler.cpp",
+                "vendor/swift/lib/Demangling/Errors.cpp",
                 "vendor/swift/lib/Demangling/ManglingUtils.cpp",
                 "vendor/swift/lib/Demangling/NodeDumper.cpp",
                 "vendor/swift/lib/Demangling/NodePrinter.cpp",
-                "vendor/swift/lib/Demangling/OldDemangler.cpp",
+                // "vendor/swift/lib/Demangling/OldDemangler.cpp",
                 // "vendor/swift/lib/Demangling/OldRemangler.cpp",
                 "vendor/swift/lib/Demangling/Punycode.cpp",
                 "vendor/swift/lib/Demangling/Remangler.cpp",
             ])
-            .flag_if_supported("-std=c++14")
+            .flag_if_supported("-fpermissive")
+            .flag_if_supported("-Wno-changes-meaning")
             .flag("-DLLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING=1")
+            .flag("-DSWIFT_STDLIB_HAS_TYPE_PRINTING=1")
             .warnings(false)
             .include("vendor/swift/include")
             .compile("swiftdemangle");
diff --git a/symbolic-demangle/src/lib.rs b/symbolic-demangle/src/lib.rs
index b6a3ec031..acc9c3cb1 100644
--- a/symbolic-demangle/src/lib.rs
+++ b/symbolic-demangle/src/lib.rs
@@ -416,7 +416,7 @@ pub trait Demangle {
     fn try_demangle(&self, opts: DemangleOptions) -> Cow<'_, str>;
 }
 
-impl<'a> Demangle for Name<'a> {
+impl Demangle for Name<'_> {
     fn detect_language(&self) -> Language {
         if self.language() != Language::Unknown {
             return self.language();
diff --git a/symbolic-demangle/tests/test_swift.rs b/symbolic-demangle/tests/test_swift.rs
index 72e1b8e70..d3994accc 100644
--- a/symbolic-demangle/tests/test_swift.rs
+++ b/symbolic-demangle/tests/test_swift.rs
@@ -147,6 +147,9 @@ fn test_demangle_swift_short() {
 
         // Swift 5.2
         "$s7ranking22propertyVersusFunctionyyAA1P_p_xtAaCRzlFyAaC_pcAaC_pcfu_" => "implicit closure #1 (P) in propertyVersusFunction<A>(P, A)",
+
+        // Causes an abort with the Swift 6.0.3 demangler.
+        "$sTB" => "$sTB",
     });
 }
 
@@ -290,6 +293,10 @@ fn test_demangle_swift_no_args() {
         "$s7ranking22propertyVersusFunctionyyAA1P_p_xtAaCRzlFyAaC_pcAaC_pcfu_" => "implicit closure #1 in propertyVersusFunction<A>",
 
         // Swift 5.5.1
-        "$s10Speediness17NetworkQualityCLIO3run10sequentialAC6ResultVSb_tYaKFZTf4nd_nTQ0_" => "(1) await resume partial function for specialized static NetworkQualityCLI.run",
+        "$s10Speediness17NetworkQualityCLIO3run10sequentialAC6ResultVSb_tYaKFZTf4nd_nTQ0_" => "specialized static NetworkQualityCLI.run",
+
+        // Swift 6.0.3
+        "$ss27withTaskCancellationHandler9operation8onCancel9isolationxxyYaKXE_yyYbXEScA_pSgYitYaKlFTwb" => "withTaskCancellationHandler<A>",
+        "$s11Supercharge2AXO7ElementPAAE8elements33_35EDDAA799FBB5B74D2F426690B0D99DLL3for2asSayqd__GSo28NSAccessibilityAttributeNamea_qd__mtSo7AXErrorVYKAcDRd__lFAC3AppC_AC6WindowCTgm5" => "specialized AX.Element.elements<A>",
     });
 }
diff --git a/symbolic-demangle/vendor/swift/1-arguments.patch b/symbolic-demangle/vendor/swift/1-arguments.patch
index 8feb835bb..5209fc4c2 100644
--- a/symbolic-demangle/vendor/swift/1-arguments.patch
+++ b/symbolic-demangle/vendor/swift/1-arguments.patch
@@ -1,14 +1,14 @@
-commit 43fca7dd2617ac93f338b5257a2e57c43dcb8154
-Author: Sebastian Zivota <loewenheim@mailbox.org>
-Date:   Thu Dec 2 16:15:35 2021 +0100
+commit 80e772078494a73f2fbb5e385de2092e6057d913
+Author: David Herberth <david.herberth@sentry.io>
+Date:   Thu Jan 9 10:54:28 2025 +0100
 
-    Apply patch
+    apply patch
 
 diff --git a/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangle.h b/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangle.h
-index db32dbd..f48e1c2 100644
+index f66dd7fd..940c3652 100644
 --- a/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangle.h
 +++ b/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangle.h
-@@ -59,6 +59,7 @@ struct DemangleOptions {
+@@ -58,6 +58,7 @@ struct DemangleOptions {
    bool ShortenArchetype = false;
    bool ShowPrivateDiscriminators = true;
    bool ShowFunctionArgumentTypes = true;
@@ -21,21 +21,21 @@ index db32dbd..f48e1c2 100644
      Opt.ShowPrivateDiscriminators = false;
      Opt.ShowFunctionArgumentTypes = false;
 +    Opt.ShowFunctionReturnType = false;
+     Opt.ShowAsyncResumePartial = false;
      return Opt;
    };
- };
 diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/NodePrinter.cpp b/symbolic-demangle/vendor/swift/lib/Demangling/NodePrinter.cpp
-index 2a9c0dc..34fa785 100644
+index 6c309bbf..5b251e8d 100644
 --- a/symbolic-demangle/vendor/swift/lib/Demangling/NodePrinter.cpp
 +++ b/symbolic-demangle/vendor/swift/lib/Demangling/NodePrinter.cpp
-@@ -863,10 +863,11 @@ private:
+@@ -955,10 +955,11 @@ private:
      if (isSendable)
        Printer << "@Sendable ";
  
--    printFunctionParameters(LabelList, node->getChild(startIndex),
+-    printFunctionParameters(LabelList, node->getChild(argIndex), depth,
 -                            Options.ShowFunctionArgumentTypes);
 +    if (Options.ShowFunctionArgumentTypes) {
-+      printFunctionParameters(LabelList, node->getChild(startIndex), true);
++      printFunctionParameters(LabelList, node->getChild(argIndex), depth, true);
 +    }
  
 -    if (!Options.ShowFunctionArgumentTypes)
@@ -43,3 +43,14 @@ index 2a9c0dc..34fa785 100644
        return;
  
      if (isAsync)
+diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/Demangler.cpp b/symbolic-demangle/vendor/swift/lib/Demangling/Demangler.cpp
+index 6c309bbf..5b251e8d 100644
+--- a/symbolic-demangle/vendor/swift/lib/Demangling/Demangler.cpp
++++ b/symbolic-demangle/vendor/swift/lib/Demangling/Demangler.cpp
+@@ -3423,7 +3423,6 @@ NodePointer Demangler::demangleSpecAttributes(Node::Kind SpecKind) {
+
+   int PassID = (int)nextChar() - '0';
+   if (PassID < 0 || PassID >= MAX_SPECIALIZATION_PASS) {
+-    assert(false && "unexpected pass id");
+     return nullptr;
+   }
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/ADL.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/ADL.h
new file mode 100644
index 000000000..812d9a4b5
--- /dev/null
+++ b/symbolic-demangle/vendor/swift/include/llvm/ADT/ADL.h
@@ -0,0 +1,135 @@
+//===- llvm/ADT/ADL.h - Argument dependent lookup utilities -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_ADL_H
+#define LLVM_ADT_ADL_H
+
+#include <type_traits>
+#include <iterator>
+#include <utility>
+
+namespace llvm {
+
+// Only used by compiler if both template types are the same.  Useful when
+// using SFINAE to test for the existence of member functions.
+template <typename T, T> struct SameType;
+
+namespace adl_detail {
+
+using std::begin;
+
+template <typename RangeT>
+constexpr auto begin_impl(RangeT &&range)
+    -> decltype(begin(std::forward<RangeT>(range))) {
+  return begin(std::forward<RangeT>(range));
+}
+
+using std::end;
+
+template <typename RangeT>
+constexpr auto end_impl(RangeT &&range)
+    -> decltype(end(std::forward<RangeT>(range))) {
+  return end(std::forward<RangeT>(range));
+}
+
+using std::rbegin;
+
+template <typename RangeT>
+constexpr auto rbegin_impl(RangeT &&range)
+    -> decltype(rbegin(std::forward<RangeT>(range))) {
+  return rbegin(std::forward<RangeT>(range));
+}
+
+using std::rend;
+
+template <typename RangeT>
+constexpr auto rend_impl(RangeT &&range)
+    -> decltype(rend(std::forward<RangeT>(range))) {
+  return rend(std::forward<RangeT>(range));
+}
+
+using std::swap;
+
+template <typename T>
+constexpr void swap_impl(T &&lhs,
+                         T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
+                                                         std::declval<T>()))) {
+  swap(std::forward<T>(lhs), std::forward<T>(rhs));
+}
+
+using std::size;
+
+template <typename RangeT>
+constexpr auto size_impl(RangeT &&range)
+    -> decltype(size(std::forward<RangeT>(range))) {
+  return size(std::forward<RangeT>(range));
+}
+
+} // end namespace adl_detail
+
+/// Returns the begin iterator to \p range using `std::begin` and
+/// function found through Argument-Dependent Lookup (ADL).
+template <typename RangeT>
+constexpr auto adl_begin(RangeT &&range)
+    -> decltype(adl_detail::begin_impl(std::forward<RangeT>(range))) {
+  return adl_detail::begin_impl(std::forward<RangeT>(range));
+}
+
+/// Returns the end iterator to \p range using `std::end` and
+/// functions found through Argument-Dependent Lookup (ADL).
+template <typename RangeT>
+constexpr auto adl_end(RangeT &&range)
+    -> decltype(adl_detail::end_impl(std::forward<RangeT>(range))) {
+  return adl_detail::end_impl(std::forward<RangeT>(range));
+}
+
+/// Returns the reverse-begin iterator to \p range using `std::rbegin` and
+/// function found through Argument-Dependent Lookup (ADL).
+template <typename RangeT>
+constexpr auto adl_rbegin(RangeT &&range)
+    -> decltype(adl_detail::rbegin_impl(std::forward<RangeT>(range))) {
+  return adl_detail::rbegin_impl(std::forward<RangeT>(range));
+}
+
+/// Returns the reverse-end iterator to \p range using `std::rend` and
+/// functions found through Argument-Dependent Lookup (ADL).
+template <typename RangeT>
+constexpr auto adl_rend(RangeT &&range)
+    -> decltype(adl_detail::rend_impl(std::forward<RangeT>(range))) {
+  return adl_detail::rend_impl(std::forward<RangeT>(range));
+}
+
+/// Swaps \p lhs with \p rhs using `std::swap` and functions found through
+/// Argument-Dependent Lookup (ADL).
+template <typename T>
+constexpr void adl_swap(T &&lhs, T &&rhs) noexcept(
+    noexcept(adl_detail::swap_impl(std::declval<T>(), std::declval<T>()))) {
+  adl_detail::swap_impl(std::forward<T>(lhs), std::forward<T>(rhs));
+}
+
+/// Returns the size of \p range using `std::size` and functions found through
+/// Argument-Dependent Lookup (ADL).
+template <typename RangeT>
+constexpr auto adl_size(RangeT &&range)
+    -> decltype(adl_detail::size_impl(std::forward<RangeT>(range))) {
+  return adl_detail::size_impl(std::forward<RangeT>(range));
+}
+
+namespace detail {
+
+template <typename RangeT>
+using IterOfRange = decltype(adl_begin(std::declval<RangeT &>()));
+
+template <typename RangeT>
+using ValueOfRange =
+    std::remove_reference_t<decltype(*adl_begin(std::declval<RangeT &>()))>;
+
+} // namespace detail
+} // namespace llvm
+
+#endif // LLVM_ADT_ADL_H
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/DenseMapInfo.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/DenseMapInfo.h
new file mode 100644
index 000000000..07c37e353
--- /dev/null
+++ b/symbolic-demangle/vendor/swift/include/llvm/ADT/DenseMapInfo.h
@@ -0,0 +1,325 @@
+//===- llvm/ADT/DenseMapInfo.h - Type traits for DenseMap -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines DenseMapInfo traits for DenseMap.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_DENSEMAPINFO_H
+#define LLVM_ADT_DENSEMAPINFO_H
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+
+namespace densemap::detail {
+// A bit mixer with very low latency using one multiplications and one
+// xor-shift. The constant is from splitmix64.
+inline uint64_t mix(uint64_t x) {
+  x *= 0xbf58476d1ce4e5b9u;
+  x ^= x >> 31;
+  return x;
+}
+} // namespace densemap::detail
+
+namespace detail {
+
+/// Simplistic combination of 32-bit hash values into 32-bit hash values.
+inline unsigned combineHashValue(unsigned a, unsigned b) {
+  uint64_t x = (uint64_t)a << 32 | (uint64_t)b;
+  return (unsigned)densemap::detail::mix(x);
+}
+
+} // end namespace detail
+
+/// An information struct used to provide DenseMap with the various necessary
+/// components for a given value type `T`. `Enable` is an optional additional
+/// parameter that is used to support SFINAE (generally using std::enable_if_t)
+/// in derived DenseMapInfo specializations; in non-SFINAE use cases this should
+/// just be `void`.
+template<typename T, typename Enable = void>
+struct DenseMapInfo {
+  //static inline T getEmptyKey();
+  //static inline T getTombstoneKey();
+  //static unsigned getHashValue(const T &Val);
+  //static bool isEqual(const T &LHS, const T &RHS);
+};
+
+// Provide DenseMapInfo for all pointers. Come up with sentinel pointer values
+// that are aligned to alignof(T) bytes, but try to avoid requiring T to be
+// complete. This allows clients to instantiate DenseMap<T*, ...> with forward
+// declared key types. Assume that no pointer key type requires more than 4096
+// bytes of alignment.
+template<typename T>
+struct DenseMapInfo<T*> {
+  // The following should hold, but it would require T to be complete:
+  // static_assert(alignof(T) <= (1 << Log2MaxAlign),
+  //               "DenseMap does not support pointer keys requiring more than "
+  //               "Log2MaxAlign bits of alignment");
+  static constexpr uintptr_t Log2MaxAlign = 12;
+
+  static inline T* getEmptyKey() {
+    uintptr_t Val = static_cast<uintptr_t>(-1);
+    Val <<= Log2MaxAlign;
+    return reinterpret_cast<T*>(Val);
+  }
+
+  static inline T* getTombstoneKey() {
+    uintptr_t Val = static_cast<uintptr_t>(-2);
+    Val <<= Log2MaxAlign;
+    return reinterpret_cast<T*>(Val);
+  }
+
+  static unsigned getHashValue(const T *PtrVal) {
+    return (unsigned((uintptr_t)PtrVal) >> 4) ^
+           (unsigned((uintptr_t)PtrVal) >> 9);
+  }
+
+  static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
+};
+
+// Provide DenseMapInfo for chars.
+template<> struct DenseMapInfo<char> {
+  static inline char getEmptyKey() { return ~0; }
+  static inline char getTombstoneKey() { return ~0 - 1; }
+  static unsigned getHashValue(const char& Val) { return Val * 37U; }
+
+  static bool isEqual(const char &LHS, const char &RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for unsigned chars.
+template <> struct DenseMapInfo<unsigned char> {
+  static inline unsigned char getEmptyKey() { return ~0; }
+  static inline unsigned char getTombstoneKey() { return ~0 - 1; }
+  static unsigned getHashValue(const unsigned char &Val) { return Val * 37U; }
+
+  static bool isEqual(const unsigned char &LHS, const unsigned char &RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for unsigned shorts.
+template <> struct DenseMapInfo<unsigned short> {
+  static inline unsigned short getEmptyKey() { return 0xFFFF; }
+  static inline unsigned short getTombstoneKey() { return 0xFFFF - 1; }
+  static unsigned getHashValue(const unsigned short &Val) { return Val * 37U; }
+
+  static bool isEqual(const unsigned short &LHS, const unsigned short &RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for unsigned ints.
+template<> struct DenseMapInfo<unsigned> {
+  static inline unsigned getEmptyKey() { return ~0U; }
+  static inline unsigned getTombstoneKey() { return ~0U - 1; }
+  static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }
+
+  static bool isEqual(const unsigned& LHS, const unsigned& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for unsigned longs.
+template<> struct DenseMapInfo<unsigned long> {
+  static inline unsigned long getEmptyKey() { return ~0UL; }
+  static inline unsigned long getTombstoneKey() { return ~0UL - 1L; }
+
+  static unsigned getHashValue(const unsigned long& Val) {
+    if constexpr (sizeof(Val) == 4)
+      return DenseMapInfo<unsigned>::getHashValue(Val);
+    else
+      return densemap::detail::mix(Val);
+  }
+
+  static bool isEqual(const unsigned long& LHS, const unsigned long& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for unsigned long longs.
+template<> struct DenseMapInfo<unsigned long long> {
+  static inline unsigned long long getEmptyKey() { return ~0ULL; }
+  static inline unsigned long long getTombstoneKey() { return ~0ULL - 1ULL; }
+
+  static unsigned getHashValue(const unsigned long long& Val) {
+    return densemap::detail::mix(Val);
+  }
+
+  static bool isEqual(const unsigned long long& LHS,
+                      const unsigned long long& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for shorts.
+template <> struct DenseMapInfo<short> {
+  static inline short getEmptyKey() { return 0x7FFF; }
+  static inline short getTombstoneKey() { return -0x7FFF - 1; }
+  static unsigned getHashValue(const short &Val) { return Val * 37U; }
+  static bool isEqual(const short &LHS, const short &RHS) { return LHS == RHS; }
+};
+
+// Provide DenseMapInfo for ints.
+template<> struct DenseMapInfo<int> {
+  static inline int getEmptyKey() { return 0x7fffffff; }
+  static inline int getTombstoneKey() { return -0x7fffffff - 1; }
+  static unsigned getHashValue(const int& Val) { return (unsigned)(Val * 37U); }
+
+  static bool isEqual(const int& LHS, const int& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for longs.
+template<> struct DenseMapInfo<long> {
+  static inline long getEmptyKey() {
+    return (1UL << (sizeof(long) * 8 - 1)) - 1UL;
+  }
+
+  static inline long getTombstoneKey() { return getEmptyKey() - 1L; }
+
+  static unsigned getHashValue(const long& Val) {
+    return (unsigned)(Val * 37UL);
+  }
+
+  static bool isEqual(const long& LHS, const long& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for long longs.
+template<> struct DenseMapInfo<long long> {
+  static inline long long getEmptyKey() { return 0x7fffffffffffffffLL; }
+  static inline long long getTombstoneKey() { return -0x7fffffffffffffffLL-1; }
+
+  static unsigned getHashValue(const long long& Val) {
+    return (unsigned)(Val * 37ULL);
+  }
+
+  static bool isEqual(const long long& LHS,
+                      const long long& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for all pairs whose members have info.
+template<typename T, typename U>
+struct DenseMapInfo<std::pair<T, U>> {
+  using Pair = std::pair<T, U>;
+  using FirstInfo = DenseMapInfo<T>;
+  using SecondInfo = DenseMapInfo<U>;
+
+  static inline Pair getEmptyKey() {
+    return std::make_pair(FirstInfo::getEmptyKey(),
+                          SecondInfo::getEmptyKey());
+  }
+
+  static inline Pair getTombstoneKey() {
+    return std::make_pair(FirstInfo::getTombstoneKey(),
+                          SecondInfo::getTombstoneKey());
+  }
+
+  static unsigned getHashValue(const Pair& PairVal) {
+    return detail::combineHashValue(FirstInfo::getHashValue(PairVal.first),
+                                    SecondInfo::getHashValue(PairVal.second));
+  }
+
+  // Expose an additional function intended to be used by other
+  // specializations of DenseMapInfo without needing to know how
+  // to combine hash values manually
+  static unsigned getHashValuePiecewise(const T &First, const U &Second) {
+    return detail::combineHashValue(FirstInfo::getHashValue(First),
+                                    SecondInfo::getHashValue(Second));
+  }
+
+  static bool isEqual(const Pair &LHS, const Pair &RHS) {
+    return FirstInfo::isEqual(LHS.first, RHS.first) &&
+           SecondInfo::isEqual(LHS.second, RHS.second);
+  }
+};
+
+// Provide DenseMapInfo for all tuples whose members have info.
+template <typename... Ts> struct DenseMapInfo<std::tuple<Ts...>> {
+  using Tuple = std::tuple<Ts...>;
+
+  static inline Tuple getEmptyKey() {
+    return Tuple(DenseMapInfo<Ts>::getEmptyKey()...);
+  }
+
+  static inline Tuple getTombstoneKey() {
+    return Tuple(DenseMapInfo<Ts>::getTombstoneKey()...);
+  }
+
+  template <unsigned I>
+  static unsigned getHashValueImpl(const Tuple &values, std::false_type) {
+    using EltType = std::tuple_element_t<I, Tuple>;
+    std::integral_constant<bool, I + 1 == sizeof...(Ts)> atEnd;
+    return detail::combineHashValue(
+        DenseMapInfo<EltType>::getHashValue(std::get<I>(values)),
+        getHashValueImpl<I + 1>(values, atEnd));
+  }
+
+  template <unsigned I>
+  static unsigned getHashValueImpl(const Tuple &, std::true_type) {
+    return 0;
+  }
+
+  static unsigned getHashValue(const std::tuple<Ts...> &values) {
+    std::integral_constant<bool, 0 == sizeof...(Ts)> atEnd;
+    return getHashValueImpl<0>(values, atEnd);
+  }
+
+  template <unsigned I>
+  static bool isEqualImpl(const Tuple &lhs, const Tuple &rhs, std::false_type) {
+    using EltType = std::tuple_element_t<I, Tuple>;
+    std::integral_constant<bool, I + 1 == sizeof...(Ts)> atEnd;
+    return DenseMapInfo<EltType>::isEqual(std::get<I>(lhs), std::get<I>(rhs)) &&
+           isEqualImpl<I + 1>(lhs, rhs, atEnd);
+  }
+
+  template <unsigned I>
+  static bool isEqualImpl(const Tuple &, const Tuple &, std::true_type) {
+    return true;
+  }
+
+  static bool isEqual(const Tuple &lhs, const Tuple &rhs) {
+    std::integral_constant<bool, 0 == sizeof...(Ts)> atEnd;
+    return isEqualImpl<0>(lhs, rhs, atEnd);
+  }
+};
+
+// Provide DenseMapInfo for enum classes.
+template <typename Enum>
+struct DenseMapInfo<Enum, std::enable_if_t<std::is_enum_v<Enum>>> {
+  using UnderlyingType = std::underlying_type_t<Enum>;
+  using Info = DenseMapInfo<UnderlyingType>;
+
+  static Enum getEmptyKey() { return static_cast<Enum>(Info::getEmptyKey()); }
+
+  static Enum getTombstoneKey() {
+    return static_cast<Enum>(Info::getTombstoneKey());
+  }
+
+  static unsigned getHashValue(const Enum &Val) {
+    return Info::getHashValue(static_cast<UnderlyingType>(Val));
+  }
+
+  static bool isEqual(const Enum &LHS, const Enum &RHS) { return LHS == RHS; }
+};
+} // end namespace llvm
+
+#endif // LLVM_ADT_DENSEMAPINFO_H
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/Hashing.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/Hashing.h
index e296c1c53..a5477362a 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/ADT/Hashing.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/ADT/Hashing.h
@@ -51,11 +51,13 @@
 #include <algorithm>
 #include <cassert>
 #include <cstring>
+#include <optional>
 #include <string>
 #include <tuple>
 #include <utility>
 
 namespace llvm {
+template <typename T, typename Enable> struct DenseMapInfo;
 
 /// An opaque object representing a hash code.
 ///
@@ -121,6 +123,8 @@ hash_code hash_value(const std::tuple<Ts...> &arg);
 template <typename T>
 hash_code hash_value(const std::basic_string<T> &arg);
 
+/// Compute a hash_code for a standard string.
+template <typename T> hash_code hash_value(const std::optional<T> &arg);
 
 /// Override the execution seed with a fixed value.
 ///
@@ -215,29 +219,30 @@ inline uint64_t hash_17to32_bytes(const char *s, size_t len, uint64_t seed) {
   uint64_t b = fetch64(s + 8);
   uint64_t c = fetch64(s + len - 8) * k2;
   uint64_t d = fetch64(s + len - 16) * k0;
-  return hash_16_bytes(rotate(a - b, 43) + rotate(c ^ seed, 30) + d,
-                       a + rotate(b ^ k3, 20) - c + len + seed);
+  return hash_16_bytes(llvm::rotr<uint64_t>(a - b, 43) +
+                           llvm::rotr<uint64_t>(c ^ seed, 30) + d,
+                       a + llvm::rotr<uint64_t>(b ^ k3, 20) - c + len + seed);
 }
 
 inline uint64_t hash_33to64_bytes(const char *s, size_t len, uint64_t seed) {
   uint64_t z = fetch64(s + 24);
   uint64_t a = fetch64(s) + (len + fetch64(s + len - 16)) * k0;
-  uint64_t b = rotate(a + z, 52);
-  uint64_t c = rotate(a, 37);
+  uint64_t b = llvm::rotr<uint64_t>(a + z, 52);
+  uint64_t c = llvm::rotr<uint64_t>(a, 37);
   a += fetch64(s + 8);
-  c += rotate(a, 7);
+  c += llvm::rotr<uint64_t>(a, 7);
   a += fetch64(s + 16);
   uint64_t vf = a + z;
-  uint64_t vs = b + rotate(a, 31) + c;
+  uint64_t vs = b + llvm::rotr<uint64_t>(a, 31) + c;
   a = fetch64(s + 16) + fetch64(s + len - 32);
   z = fetch64(s + len - 8);
-  b = rotate(a + z, 52);
-  c = rotate(a, 37);
+  b = llvm::rotr<uint64_t>(a + z, 52);
+  c = llvm::rotr<uint64_t>(a, 37);
   a += fetch64(s + len - 24);
-  c += rotate(a, 7);
+  c += llvm::rotr<uint64_t>(a, 7);
   a += fetch64(s + len - 16);
   uint64_t wf = a + z;
-  uint64_t ws = b + rotate(a, 31) + c;
+  uint64_t ws = b + llvm::rotr<uint64_t>(a, 31) + c;
   uint64_t r = shift_mix((vf + ws) * k2 + (wf + vs) * k0);
   return shift_mix((seed ^ (r * k0)) + vs) * k2;
 }
@@ -267,9 +272,13 @@ struct hash_state {
   /// seed and the first 64-byte chunk.
   /// This effectively performs the initial mix.
   static hash_state create(const char *s, uint64_t seed) {
-    hash_state state = {
-      0, seed, hash_16_bytes(seed, k1), rotate(seed ^ k1, 49),
-      seed * k1, shift_mix(seed), 0 };
+    hash_state state = {0,
+                        seed,
+                        hash_16_bytes(seed, k1),
+                        llvm::rotr<uint64_t>(seed ^ k1, 49),
+                        seed * k1,
+                        shift_mix(seed),
+                        0};
     state.h6 = hash_16_bytes(state.h4, state.h5);
     state.mix(s);
     return state;
@@ -280,10 +289,10 @@ struct hash_state {
   static void mix_32_bytes(const char *s, uint64_t &a, uint64_t &b) {
     a += fetch64(s);
     uint64_t c = fetch64(s + 24);
-    b = rotate(b + a + c, 21);
+    b = llvm::rotr<uint64_t>(b + a + c, 21);
     uint64_t d = a;
     a += fetch64(s + 8) + fetch64(s + 16);
-    b += rotate(a, 44) + d;
+    b += llvm::rotr<uint64_t>(a, 44) + d;
     a += c;
   }
 
@@ -291,11 +300,11 @@ struct hash_state {
   /// We mix all 64 bytes even when the chunk length is smaller, but we
   /// record the actual length.
   void mix(const char *s) {
-    h0 = rotate(h0 + h1 + h3 + fetch64(s + 8), 37) * k1;
-    h1 = rotate(h1 + h4 + fetch64(s + 48), 42) * k1;
+    h0 = llvm::rotr<uint64_t>(h0 + h1 + h3 + fetch64(s + 8), 37) * k1;
+    h1 = llvm::rotr<uint64_t>(h1 + h4 + fetch64(s + 48), 42) * k1;
     h0 ^= h6;
     h1 += h3 + fetch64(s + 40);
-    h2 = rotate(h2 + h5, 33) * k1;
+    h2 = llvm::rotr<uint64_t>(h2 + h5, 33) * k1;
     h3 = h4 * k1;
     h4 = h0 + h5;
     mix_32_bytes(s, h3, h4);
@@ -650,24 +659,8 @@ hash_code hash_value(const std::pair<T, U> &arg) {
   return hash_combine(arg.first, arg.second);
 }
 
-// Implementation details for the hash_value overload for std::tuple<...>(...).
-namespace hashing {
-namespace detail {
-
-template <typename... Ts, std::size_t... Indices>
-hash_code hash_value_tuple_helper(const std::tuple<Ts...> &arg,
-                                  std::index_sequence<Indices...>) {
-  return hash_combine(std::get<Indices>(arg)...);
-}
-
-} // namespace detail
-} // namespace hashing
-
-template <typename... Ts>
-hash_code hash_value(const std::tuple<Ts...> &arg) {
-  // TODO: Use std::apply when LLVM starts using C++17.
-  return ::llvm::hashing::detail::hash_value_tuple_helper(
-      arg, typename std::index_sequence_for<Ts...>());
+template <typename... Ts> hash_code hash_value(const std::tuple<Ts...> &arg) {
+  return std::apply([](const auto &...xs) { return hash_combine(xs...); }, arg);
 }
 
 // Declared and documented above, but defined here so that any of the hashing
@@ -677,6 +670,31 @@ hash_code hash_value(const std::basic_string<T> &arg) {
   return hash_combine_range(arg.begin(), arg.end());
 }
 
+template <typename T> hash_code hash_value(const std::optional<T> &arg) {
+  return arg ? hash_combine(true, *arg) : hash_value(false);
+}
+
+template <> struct DenseMapInfo<hash_code, void> {
+  static inline hash_code getEmptyKey() { return hash_code(-1); }
+  static inline hash_code getTombstoneKey() { return hash_code(-2); }
+  static unsigned getHashValue(hash_code val) {
+    return static_cast<unsigned>(size_t(val));
+  }
+  static bool isEqual(hash_code LHS, hash_code RHS) { return LHS == RHS; }
+};
+
 } // namespace llvm
 
+/// Implement std::hash so that hash_code can be used in STL containers.
+namespace std {
+
+template<>
+struct hash<llvm::hash_code> {
+  size_t operator()(llvm::hash_code const& Val) const {
+    return Val;
+  }
+};
+
+} // namespace std;
+
 #endif
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/None.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/None.h
deleted file mode 100644
index 004ca0ac5..000000000
--- a/symbolic-demangle/vendor/swift/include/llvm/ADT/None.h
+++ /dev/null
@@ -1,26 +0,0 @@
-//===-- None.h - Simple null value for implicit construction ------*- C++ -*-=//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file provides None, an enumerator for use in implicit constructors
-//  of various (usually templated) types to make such construction more
-//  terse.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_NONE_H
-#define LLVM_ADT_NONE_H
-
-namespace llvm {
-/// A simple null object to allow implicit construction of Optional<T>
-/// and similar types without having to spell out the specialization's name.
-// (constant value 1 in an attempt to workaround MSVC build issue... )
-enum class NoneType { None = 1 };
-const NoneType None = NoneType::None;
-}
-
-#endif
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/Optional.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/Optional.h
deleted file mode 100644
index cdbf2e353..000000000
--- a/symbolic-demangle/vendor/swift/include/llvm/ADT/Optional.h
+++ /dev/null
@@ -1,496 +0,0 @@
-//===- Optional.h - Simple variant for passing optional values --*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file provides Optional, a template class modeled in the spirit of
-//  OCaml's 'opt' variant.  The idea is to strongly type whether or not
-//  a value can be optional.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_OPTIONAL_H
-#define LLVM_ADT_OPTIONAL_H
-
-#include "llvm/ADT/Hashing.h"
-#include "llvm/ADT/None.h"
-#include "llvm/ADT/STLForwardCompat.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/type_traits.h"
-#include <cassert>
-#include <memory>
-#include <new>
-#include <utility>
-
-namespace llvm {
-
-class raw_ostream;
-
-namespace optional_detail {
-
-/// Storage for any type.
-//
-// The specialization condition intentionally uses
-// llvm::is_trivially_copy_constructible instead of
-// std::is_trivially_copy_constructible.  GCC versions prior to 7.4 may
-// instantiate the copy constructor of `T` when
-// std::is_trivially_copy_constructible is instantiated.  This causes
-// compilation to fail if we query the trivially copy constructible property of
-// a class which is not copy constructible.
-//
-// The current implementation of OptionalStorage insists that in order to use
-// the trivial specialization, the value_type must be trivially copy
-// constructible and trivially copy assignable due to =default implementations
-// of the copy/move constructor/assignment.  It does not follow that this is
-// necessarily the case std::is_trivially_copyable is true (hence the expanded
-// specialization condition).
-//
-// The move constructible / assignable conditions emulate the remaining behavior
-// of std::is_trivially_copyable.
-template <typename T, bool = (llvm::is_trivially_copy_constructible<T>::value &&
-                              std::is_trivially_copy_assignable<T>::value &&
-                              (std::is_trivially_move_constructible<T>::value ||
-                               !std::is_move_constructible<T>::value) &&
-                              (std::is_trivially_move_assignable<T>::value ||
-                               !std::is_move_assignable<T>::value))>
-class OptionalStorage {
-  union {
-    char empty;
-    T value;
-  };
-  bool hasVal;
-
-public:
-  ~OptionalStorage() { reset(); }
-
-  constexpr OptionalStorage() noexcept : empty(), hasVal(false) {}
-
-  constexpr OptionalStorage(OptionalStorage const &other) : OptionalStorage() {
-    if (other.hasValue()) {
-      emplace(other.value);
-    }
-  }
-  constexpr OptionalStorage(OptionalStorage &&other) : OptionalStorage() {
-    if (other.hasValue()) {
-      emplace(std::move(other.value));
-    }
-  }
-
-  template <class... Args>
-  constexpr explicit OptionalStorage(in_place_t, Args &&... args)
-      : value(std::forward<Args>(args)...), hasVal(true) {}
-
-  void reset() noexcept {
-    if (hasVal) {
-      value.~T();
-      hasVal = false;
-    }
-  }
-
-  constexpr bool hasValue() const noexcept { return hasVal; }
-
-  T &getValue() LLVM_LVALUE_FUNCTION noexcept {
-    assert(hasVal);
-    return value;
-  }
-  constexpr T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
-    assert(hasVal);
-    return value;
-  }
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-  T &&getValue() && noexcept {
-    assert(hasVal);
-    return std::move(value);
-  }
-#endif
-
-  template <class... Args> void emplace(Args &&... args) {
-    reset();
-    ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
-    hasVal = true;
-  }
-
-  OptionalStorage &operator=(T const &y) {
-    if (hasValue()) {
-      value = y;
-    } else {
-      ::new ((void *)std::addressof(value)) T(y);
-      hasVal = true;
-    }
-    return *this;
-  }
-  OptionalStorage &operator=(T &&y) {
-    if (hasValue()) {
-      value = std::move(y);
-    } else {
-      ::new ((void *)std::addressof(value)) T(std::move(y));
-      hasVal = true;
-    }
-    return *this;
-  }
-
-  OptionalStorage &operator=(OptionalStorage const &other) {
-    if (other.hasValue()) {
-      if (hasValue()) {
-        value = other.value;
-      } else {
-        ::new ((void *)std::addressof(value)) T(other.value);
-        hasVal = true;
-      }
-    } else {
-      reset();
-    }
-    return *this;
-  }
-
-  OptionalStorage &operator=(OptionalStorage &&other) {
-    if (other.hasValue()) {
-      if (hasValue()) {
-        value = std::move(other.value);
-      } else {
-        ::new ((void *)std::addressof(value)) T(std::move(other.value));
-        hasVal = true;
-      }
-    } else {
-      reset();
-    }
-    return *this;
-  }
-};
-
-template <typename T> class OptionalStorage<T, true> {
-  union {
-    char empty;
-    T value;
-  };
-  bool hasVal = false;
-
-public:
-  ~OptionalStorage() = default;
-
-  constexpr OptionalStorage() noexcept : empty{} {}
-
-  constexpr OptionalStorage(OptionalStorage const &other) = default;
-  constexpr OptionalStorage(OptionalStorage &&other) = default;
-
-  OptionalStorage &operator=(OptionalStorage const &other) = default;
-  OptionalStorage &operator=(OptionalStorage &&other) = default;
-
-  template <class... Args>
-  constexpr explicit OptionalStorage(in_place_t, Args &&... args)
-      : value(std::forward<Args>(args)...), hasVal(true) {}
-
-  void reset() noexcept {
-    if (hasVal) {
-      value.~T();
-      hasVal = false;
-    }
-  }
-
-  constexpr bool hasValue() const noexcept { return hasVal; }
-
-  T &getValue() LLVM_LVALUE_FUNCTION noexcept {
-    assert(hasVal);
-    return value;
-  }
-  constexpr T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
-    assert(hasVal);
-    return value;
-  }
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-  T &&getValue() && noexcept {
-    assert(hasVal);
-    return std::move(value);
-  }
-#endif
-
-  template <class... Args> void emplace(Args &&... args) {
-    reset();
-    ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
-    hasVal = true;
-  }
-
-  OptionalStorage &operator=(T const &y) {
-    if (hasValue()) {
-      value = y;
-    } else {
-      ::new ((void *)std::addressof(value)) T(y);
-      hasVal = true;
-    }
-    return *this;
-  }
-  OptionalStorage &operator=(T &&y) {
-    if (hasValue()) {
-      value = std::move(y);
-    } else {
-      ::new ((void *)std::addressof(value)) T(std::move(y));
-      hasVal = true;
-    }
-    return *this;
-  }
-};
-
-} // namespace optional_detail
-
-template <typename T> class Optional {
-  optional_detail::OptionalStorage<T> Storage;
-
-public:
-  using value_type = T;
-
-  constexpr Optional() {}
-  constexpr Optional(NoneType) {}
-
-  constexpr Optional(const T &y) : Storage(in_place, y) {}
-  constexpr Optional(const Optional &O) = default;
-
-  constexpr Optional(T &&y) : Storage(in_place, std::move(y)) {}
-  constexpr Optional(Optional &&O) = default;
-
-  template <typename... ArgTypes>
-  constexpr Optional(in_place_t, ArgTypes &&...Args)
-      : Storage(in_place, std::forward<ArgTypes>(Args)...) {}
-
-  Optional &operator=(T &&y) {
-    Storage = std::move(y);
-    return *this;
-  }
-  Optional &operator=(Optional &&O) = default;
-
-  /// Create a new object by constructing it in place with the given arguments.
-  template <typename... ArgTypes> void emplace(ArgTypes &&... Args) {
-    Storage.emplace(std::forward<ArgTypes>(Args)...);
-  }
-
-  static constexpr Optional create(const T *y) {
-    return y ? Optional(*y) : Optional();
-  }
-
-  Optional &operator=(const T &y) {
-    Storage = y;
-    return *this;
-  }
-  Optional &operator=(const Optional &O) = default;
-
-  void reset() { Storage.reset(); }
-
-  constexpr const T *getPointer() const { return &Storage.getValue(); }
-  T *getPointer() { return &Storage.getValue(); }
-  constexpr const T &getValue() const LLVM_LVALUE_FUNCTION {
-    return Storage.getValue();
-  }
-  T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
-
-  constexpr explicit operator bool() const { return hasValue(); }
-  constexpr bool hasValue() const { return Storage.hasValue(); }
-  constexpr const T *operator->() const { return getPointer(); }
-  T *operator->() { return getPointer(); }
-  constexpr const T &operator*() const LLVM_LVALUE_FUNCTION {
-    return getValue();
-  }
-  T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
-
-  template <typename U>
-  constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
-    return hasValue() ? getValue() : std::forward<U>(value);
-  }
-
-  /// Apply a function to the value if present; otherwise return None.
-  template <class Function>
-  auto map(const Function &F) const LLVM_LVALUE_FUNCTION
-      -> Optional<decltype(F(getValue()))> {
-    if (*this) return F(getValue());
-    return None;
-  }
-
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-  T &&getValue() && { return std::move(Storage.getValue()); }
-  T &&operator*() && { return std::move(Storage.getValue()); }
-
-  template <typename U>
-  T getValueOr(U &&value) && {
-    return hasValue() ? std::move(getValue()) : std::forward<U>(value);
-  }
-
-  /// Apply a function to the value if present; otherwise return None.
-  template <class Function>
-  auto map(const Function &F) &&
-      -> Optional<decltype(F(std::move(*this).getValue()))> {
-    if (*this) return F(std::move(*this).getValue());
-    return None;
-  }
-#endif
-};
-
-template <class T> llvm::hash_code hash_value(const Optional<T> &O) {
-  return O ? hash_combine(true, *O) : hash_value(false);
-}
-
-template <typename T, typename U>
-constexpr bool operator==(const Optional<T> &X, const Optional<U> &Y) {
-  if (X && Y)
-    return *X == *Y;
-  return X.hasValue() == Y.hasValue();
-}
-
-template <typename T, typename U>
-constexpr bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
-  return !(X == Y);
-}
-
-template <typename T, typename U>
-constexpr bool operator<(const Optional<T> &X, const Optional<U> &Y) {
-  if (X && Y)
-    return *X < *Y;
-  return X.hasValue() < Y.hasValue();
-}
-
-template <typename T, typename U>
-constexpr bool operator<=(const Optional<T> &X, const Optional<U> &Y) {
-  return !(Y < X);
-}
-
-template <typename T, typename U>
-constexpr bool operator>(const Optional<T> &X, const Optional<U> &Y) {
-  return Y < X;
-}
-
-template <typename T, typename U>
-constexpr bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
-  return !(X < Y);
-}
-
-template <typename T>
-constexpr bool operator==(const Optional<T> &X, NoneType) {
-  return !X;
-}
-
-template <typename T>
-constexpr bool operator==(NoneType, const Optional<T> &X) {
-  return X == None;
-}
-
-template <typename T>
-constexpr bool operator!=(const Optional<T> &X, NoneType) {
-  return !(X == None);
-}
-
-template <typename T>
-constexpr bool operator!=(NoneType, const Optional<T> &X) {
-  return X != None;
-}
-
-template <typename T> constexpr bool operator<(const Optional<T> &, NoneType) {
-  return false;
-}
-
-template <typename T> constexpr bool operator<(NoneType, const Optional<T> &X) {
-  return X.hasValue();
-}
-
-template <typename T>
-constexpr bool operator<=(const Optional<T> &X, NoneType) {
-  return !(None < X);
-}
-
-template <typename T>
-constexpr bool operator<=(NoneType, const Optional<T> &X) {
-  return !(X < None);
-}
-
-template <typename T> constexpr bool operator>(const Optional<T> &X, NoneType) {
-  return None < X;
-}
-
-template <typename T> constexpr bool operator>(NoneType, const Optional<T> &X) {
-  return X < None;
-}
-
-template <typename T>
-constexpr bool operator>=(const Optional<T> &X, NoneType) {
-  return None <= X;
-}
-
-template <typename T>
-constexpr bool operator>=(NoneType, const Optional<T> &X) {
-  return X <= None;
-}
-
-template <typename T>
-constexpr bool operator==(const Optional<T> &X, const T &Y) {
-  return X && *X == Y;
-}
-
-template <typename T>
-constexpr bool operator==(const T &X, const Optional<T> &Y) {
-  return Y && X == *Y;
-}
-
-template <typename T>
-constexpr bool operator!=(const Optional<T> &X, const T &Y) {
-  return !(X == Y);
-}
-
-template <typename T>
-constexpr bool operator!=(const T &X, const Optional<T> &Y) {
-  return !(X == Y);
-}
-
-template <typename T>
-constexpr bool operator<(const Optional<T> &X, const T &Y) {
-  return !X || *X < Y;
-}
-
-template <typename T>
-constexpr bool operator<(const T &X, const Optional<T> &Y) {
-  return Y && X < *Y;
-}
-
-template <typename T>
-constexpr bool operator<=(const Optional<T> &X, const T &Y) {
-  return !(Y < X);
-}
-
-template <typename T>
-constexpr bool operator<=(const T &X, const Optional<T> &Y) {
-  return !(Y < X);
-}
-
-template <typename T>
-constexpr bool operator>(const Optional<T> &X, const T &Y) {
-  return Y < X;
-}
-
-template <typename T>
-constexpr bool operator>(const T &X, const Optional<T> &Y) {
-  return Y < X;
-}
-
-template <typename T>
-constexpr bool operator>=(const Optional<T> &X, const T &Y) {
-  return !(X < Y);
-}
-
-template <typename T>
-constexpr bool operator>=(const T &X, const Optional<T> &Y) {
-  return !(X < Y);
-}
-
-raw_ostream &operator<<(raw_ostream &OS, NoneType);
-
-template <typename T, typename = decltype(std::declval<raw_ostream &>()
-                                          << std::declval<const T &>())>
-raw_ostream &operator<<(raw_ostream &OS, const Optional<T> &O) {
-  if (O)
-    OS << *O;
-  else
-    OS << None;
-  return OS;
-}
-
-} // end namespace llvm
-
-#endif // LLVM_ADT_OPTIONAL_H
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/STLExtras.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/STLExtras.h
index 372907be8..8f988d01c 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/ADT/STLExtras.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/ADT/STLExtras.h
@@ -5,19 +5,22 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
-// This file contains some templates that are useful if you are working with the
-// STL at all.
-//
-// No library is required when using these functions.
-//
+///
+/// \file
+/// This file contains some templates that are useful if you are working with
+/// the STL at all.
+///
+/// No library is required when using these functions.
+///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_STLEXTRAS_H
 #define LLVM_ADT_STLEXTRAS_H
 
-#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/ADL.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/STLForwardCompat.h"
+#include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Config/abi-breaking.h"
@@ -32,6 +35,7 @@
 #include <iterator>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -42,42 +46,24 @@
 
 namespace llvm {
 
-// Only used by compiler if both template types are the same.  Useful when
-// using SFINAE to test for the existence of member functions.
-template <typename T, T> struct SameType;
-
-namespace detail {
-
-template <typename RangeT>
-using IterOfRange = decltype(std::begin(std::declval<RangeT &>()));
-
-template <typename RangeT>
-using ValueOfRange = typename std::remove_reference<decltype(
-    *std::begin(std::declval<RangeT &>()))>::type;
-
-} // end namespace detail
-
 //===----------------------------------------------------------------------===//
 //     Extra additions to <type_traits>
 //===----------------------------------------------------------------------===//
 
 template <typename T> struct make_const_ptr {
-  using type =
-      typename std::add_pointer<typename std::add_const<T>::type>::type;
+  using type = std::add_pointer_t<std::add_const_t<T>>;
 };
 
 template <typename T> struct make_const_ref {
-  using type = typename std::add_lvalue_reference<
-      typename std::add_const<T>::type>::type;
+  using type = std::add_lvalue_reference_t<std::add_const_t<T>>;
 };
 
 namespace detail {
-template <typename...> using void_t = void;
 template <class, template <class...> class Op, class... Args> struct detector {
   using value_t = std::false_type;
 };
 template <template <class...> class Op, class... Args>
-struct detector<void_t<Op<Args...>>, Op, Args...> {
+struct detector<std::void_t<Op<Args...>>, Op, Args...> {
   using value_t = std::true_type;
 };
 } // end namespace detail
@@ -92,16 +78,6 @@ struct detector<void_t<Op<Args...>>, Op, Args...> {
 template <template <class...> class Op, class... Args>
 using is_detected = typename detail::detector<void, Op, Args...>::value_t;
 
-namespace detail {
-template <typename Callable, typename... Args>
-using is_invocable =
-    decltype(std::declval<Callable &>()(std::declval<Args>()...));
-} // namespace detail
-
-/// Check if a Callable type can be invoked with the given set of arg types.
-template <typename Callable, typename... Args>
-using is_invocable = is_detected<detail::is_invocable, Callable, Args...>;
-
 /// This class provides various trait information about a callable object.
 ///   * To access the number of arguments: Traits::num_args
 ///   * To access the type of an argument: Traits::arg_t<Index>
@@ -120,12 +96,12 @@ struct function_traits<ReturnType (ClassType::*)(Args...) const, false> {
 
   /// The type of an argument to this function.
   template <size_t Index>
-  using arg_t = typename std::tuple_element<Index, std::tuple<Args...>>::type;
+  using arg_t = std::tuple_element_t<Index, std::tuple<Args...>>;
 };
 /// Overload for class function types.
 template <typename ClassType, typename ReturnType, typename... Args>
 struct function_traits<ReturnType (ClassType::*)(Args...), false>
-    : function_traits<ReturnType (ClassType::*)(Args...) const> {};
+    : public function_traits<ReturnType (ClassType::*)(Args...) const> {};
 /// Overload for non-class function types.
 template <typename ReturnType, typename... Args>
 struct function_traits<ReturnType (*)(Args...), false> {
@@ -137,123 +113,210 @@ struct function_traits<ReturnType (*)(Args...), false> {
 
   /// The type of an argument to this function.
   template <size_t i>
-  using arg_t = typename std::tuple_element<i, std::tuple<Args...>>::type;
+  using arg_t = std::tuple_element_t<i, std::tuple<Args...>>;
 };
+template <typename ReturnType, typename... Args>
+struct function_traits<ReturnType (*const)(Args...), false>
+    : public function_traits<ReturnType (*)(Args...)> {};
 /// Overload for non-class function type references.
 template <typename ReturnType, typename... Args>
 struct function_traits<ReturnType (&)(Args...), false>
     : public function_traits<ReturnType (*)(Args...)> {};
 
-//===----------------------------------------------------------------------===//
-//     Extra additions to <functional>
-//===----------------------------------------------------------------------===//
+/// traits class for checking whether type T is one of any of the given
+/// types in the variadic list.
+template <typename T, typename... Ts>
+using is_one_of = std::disjunction<std::is_same<T, Ts>...>;
 
-template <class Ty> struct identity {
-  using argument_type = Ty;
+/// traits class for checking whether type T is a base class for all
+///  the given types in the variadic list.
+template <typename T, typename... Ts>
+using are_base_of = std::conjunction<std::is_base_of<T, Ts>...>;
 
-  Ty &operator()(Ty &self) const {
-    return self;
-  }
-  const Ty &operator()(const Ty &self) const {
-    return self;
-  }
-};
+namespace detail {
+template <typename T, typename... Us> struct TypesAreDistinct;
+template <typename T, typename... Us>
+struct TypesAreDistinct
+    : std::integral_constant<bool, !is_one_of<T, Us...>::value &&
+                                       TypesAreDistinct<Us...>::value> {};
+template <typename T> struct TypesAreDistinct<T> : std::true_type {};
+} // namespace detail
 
-/// An efficient, type-erasing, non-owning reference to a callable. This is
-/// intended for use as the type of a function parameter that is not used
-/// after the function in question returns.
+/// Determine if all types in Ts are distinct.
 ///
-/// This class does not own the callable, so it is not in general safe to store
-/// a function_ref.
-template<typename Fn> class function_ref;
-
-template<typename Ret, typename ...Params>
-class function_ref<Ret(Params...)> {
-  Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
-  intptr_t callable;
-
-  template<typename Callable>
-  static Ret callback_fn(intptr_t callable, Params ...params) {
-    return (*reinterpret_cast<Callable*>(callable))(
-        std::forward<Params>(params)...);
-  }
+/// Useful to statically assert when Ts is intended to describe a non-multi set
+/// of types.
+///
+/// Expensive (currently quadratic in sizeof(Ts...)), and so should only be
+/// asserted once per instantiation of a type which requires it.
+template <typename... Ts> struct TypesAreDistinct;
+template <> struct TypesAreDistinct<> : std::true_type {};
+template <typename... Ts>
+struct TypesAreDistinct
+    : std::integral_constant<bool, detail::TypesAreDistinct<Ts...>::value> {};
+
+/// Find the first index where a type appears in a list of types.
+///
+/// FirstIndexOfType<T, Us...>::value is the first index of T in Us.
+///
+/// Typically only meaningful when it is otherwise statically known that the
+/// type pack has no duplicate types. This should be guaranteed explicitly with
+/// static_assert(TypesAreDistinct<Us...>::value).
+///
+/// It is a compile-time error to instantiate when T is not present in Us, i.e.
+/// if is_one_of<T, Us...>::value is false.
+template <typename T, typename... Us> struct FirstIndexOfType;
+template <typename T, typename U, typename... Us>
+struct FirstIndexOfType<T, U, Us...>
+    : std::integral_constant<size_t, 1 + FirstIndexOfType<T, Us...>::value> {};
+template <typename T, typename... Us>
+struct FirstIndexOfType<T, T, Us...> : std::integral_constant<size_t, 0> {};
+
+/// Find the type at a given index in a list of types.
+///
+/// TypeAtIndex<I, Ts...> is the type at index I in Ts.
+template <size_t I, typename... Ts>
+using TypeAtIndex = std::tuple_element_t<I, std::tuple<Ts...>>;
 
-public:
-  function_ref() = default;
-  function_ref(std::nullptr_t) {}
-
-  template <typename Callable>
-  function_ref(
-      Callable &&callable,
-      // This is not the copy-constructor.
-      std::enable_if_t<!std::is_same<remove_cvref_t<Callable>,
-                                     function_ref>::value> * = nullptr,
-      // Functor must be callable and return a suitable type.
-      std::enable_if_t<std::is_void<Ret>::value ||
-                       std::is_convertible<decltype(std::declval<Callable>()(
-                                               std::declval<Params>()...)),
-                                           Ret>::value> * = nullptr)
-      : callback(callback_fn<typename std::remove_reference<Callable>::type>),
-        callable(reinterpret_cast<intptr_t>(&callable)) {}
-
-  Ret operator()(Params ...params) const {
-    return callback(callable, std::forward<Params>(params)...);
-  }
-
-  explicit operator bool() const { return callback; }
-};
+/// Helper which adds two underlying types of enumeration type.
+/// Implicit conversion to a common type is accepted.
+template <typename EnumTy1, typename EnumTy2,
+          typename UT1 = std::enable_if_t<std::is_enum<EnumTy1>::value,
+                                          std::underlying_type_t<EnumTy1>>,
+          typename UT2 = std::enable_if_t<std::is_enum<EnumTy2>::value,
+                                          std::underlying_type_t<EnumTy2>>>
+constexpr auto addEnumValues(EnumTy1 LHS, EnumTy2 RHS) {
+  return static_cast<UT1>(LHS) + static_cast<UT2>(RHS);
+}
 
 //===----------------------------------------------------------------------===//
 //     Extra additions to <iterator>
 //===----------------------------------------------------------------------===//
 
-namespace adl_detail {
+namespace callable_detail {
 
-using std::begin;
+/// Templated storage wrapper for a callable.
+///
+/// This class is consistently default constructible, copy / move
+/// constructible / assignable.
+///
+/// Supported callable types:
+///  - Function pointer
+///  - Function reference
+///  - Lambda
+///  - Function object
+template <typename T,
+          bool = std::is_function_v<std::remove_pointer_t<remove_cvref_t<T>>>>
+class Callable {
+  using value_type = std::remove_reference_t<T>;
+  using reference = value_type &;
+  using const_reference = value_type const &;
+
+  std::optional<value_type> Obj;
+
+  static_assert(!std::is_pointer_v<value_type>,
+                "Pointers to non-functions are not callable.");
 
-template <typename ContainerTy>
-decltype(auto) adl_begin(ContainerTy &&container) {
-  return begin(std::forward<ContainerTy>(container));
-}
+public:
+  Callable() = default;
+  Callable(T const &O) : Obj(std::in_place, O) {}
 
-using std::end;
+  Callable(Callable const &Other) = default;
+  Callable(Callable &&Other) = default;
 
-template <typename ContainerTy>
-decltype(auto) adl_end(ContainerTy &&container) {
-  return end(std::forward<ContainerTy>(container));
-}
+  Callable &operator=(Callable const &Other) {
+    Obj = std::nullopt;
+    if (Other.Obj)
+      Obj.emplace(*Other.Obj);
+    return *this;
+  }
 
-using std::swap;
+  Callable &operator=(Callable &&Other) {
+    Obj = std::nullopt;
+    if (Other.Obj)
+      Obj.emplace(std::move(*Other.Obj));
+    return *this;
+  }
 
-template <typename T>
-void adl_swap(T &&lhs, T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
-                                                       std::declval<T>()))) {
-  swap(std::forward<T>(lhs), std::forward<T>(rhs));
-}
+  template <typename... Pn,
+            std::enable_if_t<std::is_invocable_v<T, Pn...>, int> = 0>
+  decltype(auto) operator()(Pn &&...Params) {
+    return (*Obj)(std::forward<Pn>(Params)...);
+  }
 
-} // end namespace adl_detail
+  template <typename... Pn,
+            std::enable_if_t<std::is_invocable_v<T const, Pn...>, int> = 0>
+  decltype(auto) operator()(Pn &&...Params) const {
+    return (*Obj)(std::forward<Pn>(Params)...);
+  }
 
-template <typename ContainerTy>
-decltype(auto) adl_begin(ContainerTy &&container) {
-  return adl_detail::adl_begin(std::forward<ContainerTy>(container));
-}
+  bool valid() const { return Obj != std::nullopt; }
+  bool reset() { return Obj = std::nullopt; }
 
-template <typename ContainerTy>
-decltype(auto) adl_end(ContainerTy &&container) {
-  return adl_detail::adl_end(std::forward<ContainerTy>(container));
-}
+  operator reference() { return *Obj; }
+  operator const_reference() const { return *Obj; }
+};
 
-template <typename T>
-void adl_swap(T &&lhs, T &&rhs) noexcept(
-    noexcept(adl_detail::adl_swap(std::declval<T>(), std::declval<T>()))) {
-  adl_detail::adl_swap(std::forward<T>(lhs), std::forward<T>(rhs));
-}
+// Function specialization.  No need to waste extra space wrapping with a
+// std::optional.
+template <typename T> class Callable<T, true> {
+  static constexpr bool IsPtr = std::is_pointer_v<remove_cvref_t<T>>;
 
-/// Test whether \p RangeOrContainer is empty. Similar to C++17 std::empty.
-template <typename T>
-constexpr bool empty(const T &RangeOrContainer) {
-  return adl_begin(RangeOrContainer) == adl_end(RangeOrContainer);
-}
+  using StorageT = std::conditional_t<IsPtr, T, std::remove_reference_t<T> *>;
+  using CastT = std::conditional_t<IsPtr, T, T &>;
+
+private:
+  StorageT Func = nullptr;
+
+private:
+  template <typename In> static constexpr auto convertIn(In &&I) {
+    if constexpr (IsPtr) {
+      // Pointer... just echo it back.
+      return I;
+    } else {
+      // Must be a function reference.  Return its address.
+      return &I;
+    }
+  }
+
+public:
+  Callable() = default;
+
+  // Construct from a function pointer or reference.
+  //
+  // Disable this constructor for references to 'Callable' so we don't violate
+  // the rule of 0.
+  template < // clang-format off
+    typename FnPtrOrRef,
+    std::enable_if_t<
+      !std::is_same_v<remove_cvref_t<FnPtrOrRef>, Callable>, int
+    > = 0
+  > // clang-format on
+  Callable(FnPtrOrRef &&F) : Func(convertIn(F)) {}
+
+  template <typename... Pn,
+            std::enable_if_t<std::is_invocable_v<T, Pn...>, int> = 0>
+  decltype(auto) operator()(Pn &&...Params) const {
+    return Func(std::forward<Pn>(Params)...);
+  }
+
+  bool valid() const { return Func != nullptr; }
+  void reset() { Func = nullptr; }
+
+  operator T const &() const {
+    if constexpr (IsPtr) {
+      // T is a pointer... just echo it back.
+      return Func;
+    } else {
+      static_assert(std::is_reference_v<T>,
+                    "Expected a reference to a function.");
+      // T is a function reference... dereference the stored pointer.
+      return *Func;
+    }
+  }
+};
+
+} // namespace callable_detail
 
 /// Returns true if the given container only contains a single element.
 template <typename ContainerTy> bool hasSingleElement(ContainerTy &&C) {
@@ -268,27 +331,39 @@ template <typename T> auto drop_begin(T &&RangeOrContainer, size_t N = 1) {
                     adl_end(RangeOrContainer));
 }
 
+/// Return a range covering \p RangeOrContainer with the last N elements
+/// excluded.
+template <typename T> auto drop_end(T &&RangeOrContainer, size_t N = 1) {
+  return make_range(adl_begin(RangeOrContainer),
+                    std::prev(adl_end(RangeOrContainer), N));
+}
+
 // mapped_iterator - This is a simple iterator adapter that causes a function to
 // be applied whenever operator* is invoked on the iterator.
 
 template <typename ItTy, typename FuncTy,
-          typename FuncReturnTy =
-            decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
+          typename ReferenceTy =
+              decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
 class mapped_iterator
     : public iterator_adaptor_base<
-             mapped_iterator<ItTy, FuncTy>, ItTy,
-             typename std::iterator_traits<ItTy>::iterator_category,
-             typename std::remove_reference<FuncReturnTy>::type> {
+          mapped_iterator<ItTy, FuncTy>, ItTy,
+          typename std::iterator_traits<ItTy>::iterator_category,
+          std::remove_reference_t<ReferenceTy>,
+          typename std::iterator_traits<ItTy>::difference_type,
+          std::remove_reference_t<ReferenceTy> *, ReferenceTy> {
 public:
+  mapped_iterator() = default;
   mapped_iterator(ItTy U, FuncTy F)
     : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
 
   ItTy getCurrent() { return this->I; }
 
-  FuncReturnTy operator*() const { return F(*this->I); }
+  const FuncTy &getFunction() const { return F; }
+
+  ReferenceTy operator*() const { return F(*this->I); }
 
 private:
-  FuncTy F;
+  callable_detail::Callable<FuncTy> F{};
 };
 
 // map_iterator - Provide a convenient way to create mapped_iterators, just like
@@ -300,51 +375,53 @@ inline mapped_iterator<ItTy, FuncTy> map_iterator(ItTy I, FuncTy F) {
 
 template <class ContainerTy, class FuncTy>
 auto map_range(ContainerTy &&C, FuncTy F) {
-  return make_range(map_iterator(C.begin(), F), map_iterator(C.end(), F));
+  return make_range(map_iterator(std::begin(C), F),
+                    map_iterator(std::end(C), F));
 }
 
-/// Helper to determine if type T has a member called rbegin().
-template <typename Ty> class has_rbegin_impl {
-  using yes = char[1];
-  using no = char[2];
-
-  template <typename Inner>
-  static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
+/// A base type of mapped iterator, that is useful for building derived
+/// iterators that do not need/want to store the map function (as in
+/// mapped_iterator). These iterators must simply provide a `mapElement` method
+/// that defines how to map a value of the iterator to the provided reference
+/// type.
+template <typename DerivedT, typename ItTy, typename ReferenceTy>
+class mapped_iterator_base
+    : public iterator_adaptor_base<
+          DerivedT, ItTy,
+          typename std::iterator_traits<ItTy>::iterator_category,
+          std::remove_reference_t<ReferenceTy>,
+          typename std::iterator_traits<ItTy>::difference_type,
+          std::remove_reference_t<ReferenceTy> *, ReferenceTy> {
+public:
+  using BaseT = mapped_iterator_base;
 
-  template <typename>
-  static no& test(...);
+  mapped_iterator_base(ItTy U)
+      : mapped_iterator_base::iterator_adaptor_base(std::move(U)) {}
 
-public:
-  static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
-};
+  ItTy getCurrent() { return this->I; }
 
-/// Metafunction to determine if T& or T has a member called rbegin().
-template <typename Ty>
-struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
+  ReferenceTy operator*() const {
+    return static_cast<const DerivedT &>(*this).mapElement(*this->I);
+  }
 };
 
-// Returns an iterator_range over the given container which iterates in reverse.
-// Note that the container must have rbegin()/rend() methods for this to work.
-template <typename ContainerTy>
-auto reverse(ContainerTy &&C,
-             std::enable_if_t<has_rbegin<ContainerTy>::value> * = nullptr) {
-  return make_range(C.rbegin(), C.rend());
-}
+namespace detail {
+template <typename Range>
+using check_has_free_function_rbegin =
+    decltype(adl_rbegin(std::declval<Range &>()));
 
-// Returns a std::reverse_iterator wrapped around the given iterator.
-template <typename IteratorTy>
-std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
-  return std::reverse_iterator<IteratorTy>(It);
-}
+template <typename Range>
+static constexpr bool HasFreeFunctionRBegin =
+    is_detected<check_has_free_function_rbegin, Range>::value;
+} // namespace detail
 
 // Returns an iterator_range over the given container which iterates in reverse.
-// Note that the container must have begin()/end() methods which return
-// bidirectional iterators for this to work.
-template <typename ContainerTy>
-auto reverse(ContainerTy &&C,
-             std::enable_if_t<!has_rbegin<ContainerTy>::value> * = nullptr) {
-  return make_range(llvm::make_reverse_iterator(std::end(C)),
-                    llvm::make_reverse_iterator(std::begin(C)));
+template <typename ContainerTy> auto reverse(ContainerTy &&C) {
+  if constexpr (detail::HasFreeFunctionRBegin<ContainerTy>)
+    return make_range(adl_rbegin(C), adl_rend(C));
+  else
+    return make_range(std::make_reverse_iterator(adl_end(C)),
+                      std::make_reverse_iterator(adl_begin(C)));
 }
 
 /// An iterator adaptor that filters the elements of given inner iterators.
@@ -368,15 +445,10 @@ class filter_iterator_base
     : public iterator_adaptor_base<
           filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
           WrappedIteratorT,
-          typename std::common_type<
-              IterTag, typename std::iterator_traits<
-                           WrappedIteratorT>::iterator_category>::type> {
-  using BaseT = iterator_adaptor_base<
-      filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
-      WrappedIteratorT,
-      typename std::common_type<
-          IterTag, typename std::iterator_traits<
-                       WrappedIteratorT>::iterator_category>::type>;
+          std::common_type_t<IterTag,
+                             typename std::iterator_traits<
+                                 WrappedIteratorT>::iterator_category>> {
+  using BaseT = typename filter_iterator_base::iterator_adaptor_base;
 
 protected:
   WrappedIteratorT End;
@@ -387,6 +459,8 @@ class filter_iterator_base
       BaseT::operator++();
   }
 
+  filter_iterator_base() = default;
+
   // Construct the iterator. The begin iterator needs to know where the end
   // is, so that it can properly stop when it gets there. The end iterator only
   // needs the predicate to support bidirectional iteration.
@@ -404,6 +478,16 @@ class filter_iterator_base
     findNextValid();
     return *this;
   }
+
+  decltype(auto) operator*() const {
+    assert(BaseT::wrapped() != End && "Cannot dereference end iterator!");
+    return BaseT::operator*();
+  }
+
+  decltype(auto) operator->() const {
+    assert(BaseT::wrapped() != End && "Cannot dereference end iterator!");
+    return BaseT::operator->();
+  }
 };
 
 /// Specialization of filter_iterator_base for forward iteration only.
@@ -411,12 +495,12 @@ template <typename WrappedIteratorT, typename PredicateT,
           typename IterTag = std::forward_iterator_tag>
 class filter_iterator_impl
     : public filter_iterator_base<WrappedIteratorT, PredicateT, IterTag> {
-  using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>;
-
 public:
+  filter_iterator_impl() = default;
+
   filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
                        PredicateT Pred)
-      : BaseT(Begin, End, Pred) {}
+      : filter_iterator_impl::filter_iterator_base(Begin, End, Pred) {}
 };
 
 /// Specialization of filter_iterator_base for bidirectional iteration.
@@ -425,8 +509,8 @@ class filter_iterator_impl<WrappedIteratorT, PredicateT,
                            std::bidirectional_iterator_tag>
     : public filter_iterator_base<WrappedIteratorT, PredicateT,
                                   std::bidirectional_iterator_tag> {
-  using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT,
-                                     std::bidirectional_iterator_tag>;
+  using BaseT = typename filter_iterator_impl::filter_iterator_base;
+
   void findPrevValid() {
     while (!this->Pred(*this->I))
       BaseT::operator--();
@@ -435,6 +519,8 @@ class filter_iterator_impl<WrappedIteratorT, PredicateT,
 public:
   using BaseT::operator--;
 
+  filter_iterator_impl() = default;
+
   filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
                        PredicateT Pred)
       : BaseT(Begin, End, Pred) {}
@@ -514,9 +600,7 @@ template <typename WrappedIteratorT>
 class early_inc_iterator_impl
     : public iterator_adaptor_base<early_inc_iterator_impl<WrappedIteratorT>,
                                    WrappedIteratorT, std::input_iterator_tag> {
-  using BaseT =
-      iterator_adaptor_base<early_inc_iterator_impl<WrappedIteratorT>,
-                            WrappedIteratorT, std::input_iterator_tag>;
+  using BaseT = typename early_inc_iterator_impl::iterator_adaptor_base;
 
   using PointerT = typename std::iterator_traits<WrappedIteratorT>::pointer;
 
@@ -576,12 +660,17 @@ make_early_inc_range(RangeT &&Range) {
                     EarlyIncIteratorT(std::end(std::forward<RangeT>(Range))));
 }
 
-// forward declarations required by zip_shortest/zip_first/zip_longest
+// Forward declarations required by zip_shortest/zip_equal/zip_first/zip_longest
 template <typename R, typename UnaryPredicate>
 bool all_of(R &&range, UnaryPredicate P);
+
 template <typename R, typename UnaryPredicate>
 bool any_of(R &&range, UnaryPredicate P);
 
+template <typename T> bool all_equal(std::initializer_list<T> Values);
+
+template <typename R> constexpr size_t range_size(R &&Range);
+
 namespace detail {
 
 using std::declval;
@@ -592,25 +681,26 @@ template<typename... Iters> struct ZipTupleType {
   using type = std::tuple<decltype(*declval<Iters>())...>;
 };
 
-template <typename ZipType, typename... Iters>
+template <typename ZipType, typename ReferenceTupleType, typename... Iters>
 using zip_traits = iterator_facade_base<
-    ZipType, typename std::common_type<std::bidirectional_iterator_tag,
-                                       typename std::iterator_traits<
-                                           Iters>::iterator_category...>::type,
+    ZipType,
+    std::common_type_t<
+        std::bidirectional_iterator_tag,
+        typename std::iterator_traits<Iters>::iterator_category...>,
     // ^ TODO: Implement random access methods.
-    typename ZipTupleType<Iters...>::type,
-    typename std::iterator_traits<typename std::tuple_element<
-        0, std::tuple<Iters...>>::type>::difference_type,
+    ReferenceTupleType,
+    typename std::iterator_traits<
+        std::tuple_element_t<0, std::tuple<Iters...>>>::difference_type,
     // ^ FIXME: This follows boost::make_zip_iterator's assumption that all
     // inner iterators have the same difference_type. It would fail if, for
     // instance, the second field's difference_type were non-numeric while the
     // first is.
-    typename ZipTupleType<Iters...>::type *,
-    typename ZipTupleType<Iters...>::type>;
+    ReferenceTupleType *, ReferenceTupleType>;
 
-template <typename ZipType, typename... Iters>
-struct zip_common : public zip_traits<ZipType, Iters...> {
-  using Base = zip_traits<ZipType, Iters...>;
+template <typename ZipType, typename ReferenceTupleType, typename... Iters>
+struct zip_common : public zip_traits<ZipType, ReferenceTupleType, Iters...> {
+  using Base = zip_traits<ZipType, ReferenceTupleType, Iters...>;
+  using IndexSequence = std::index_sequence_for<Iters...>;
   using value_type = typename Base::value_type;
 
   std::tuple<Iters...> iterators;
@@ -620,113 +710,174 @@ struct zip_common : public zip_traits<ZipType, Iters...> {
     return value_type(*std::get<Ns>(iterators)...);
   }
 
-  template <size_t... Ns>
-  decltype(iterators) tup_inc(std::index_sequence<Ns...>) const {
-    return std::tuple<Iters...>(std::next(std::get<Ns>(iterators))...);
+  template <size_t... Ns> void tup_inc(std::index_sequence<Ns...>) {
+    (++std::get<Ns>(iterators), ...);
+  }
+
+  template <size_t... Ns> void tup_dec(std::index_sequence<Ns...>) {
+    (--std::get<Ns>(iterators), ...);
   }
 
   template <size_t... Ns>
-  decltype(iterators) tup_dec(std::index_sequence<Ns...>) const {
-    return std::tuple<Iters...>(std::prev(std::get<Ns>(iterators))...);
+  bool test_all_equals(const zip_common &other,
+                       std::index_sequence<Ns...>) const {
+    return ((std::get<Ns>(this->iterators) == std::get<Ns>(other.iterators)) &&
+            ...);
   }
 
 public:
   zip_common(Iters &&... ts) : iterators(std::forward<Iters>(ts)...) {}
 
-  value_type operator*() { return deref(std::index_sequence_for<Iters...>{}); }
-
-  const value_type operator*() const {
-    return deref(std::index_sequence_for<Iters...>{});
-  }
+  value_type operator*() const { return deref(IndexSequence{}); }
 
   ZipType &operator++() {
-    iterators = tup_inc(std::index_sequence_for<Iters...>{});
-    return *reinterpret_cast<ZipType *>(this);
+    tup_inc(IndexSequence{});
+    return static_cast<ZipType &>(*this);
   }
 
   ZipType &operator--() {
     static_assert(Base::IsBidirectional,
                   "All inner iterators must be at least bidirectional.");
-    iterators = tup_dec(std::index_sequence_for<Iters...>{});
-    return *reinterpret_cast<ZipType *>(this);
+    tup_dec(IndexSequence{});
+    return static_cast<ZipType &>(*this);
+  }
+
+  /// Return true if all the iterator are matching `other`'s iterators.
+  bool all_equals(zip_common &other) {
+    return test_all_equals(other, IndexSequence{});
   }
 };
 
 template <typename... Iters>
-struct zip_first : public zip_common<zip_first<Iters...>, Iters...> {
-  using Base = zip_common<zip_first<Iters...>, Iters...>;
+struct zip_first : zip_common<zip_first<Iters...>,
+                              typename ZipTupleType<Iters...>::type, Iters...> {
+  using zip_common<zip_first, typename ZipTupleType<Iters...>::type,
+                   Iters...>::zip_common;
 
-  bool operator==(const zip_first<Iters...> &other) const {
+  bool operator==(const zip_first &other) const {
     return std::get<0>(this->iterators) == std::get<0>(other.iterators);
   }
-
-  zip_first(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
 };
 
 template <typename... Iters>
-class zip_shortest : public zip_common<zip_shortest<Iters...>, Iters...> {
-  template <size_t... Ns>
-  bool test(const zip_shortest<Iters...> &other,
-            std::index_sequence<Ns...>) const {
-    return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
-                                              std::get<Ns>(other.iterators)...},
-                  identity<bool>{});
+struct zip_shortest
+    : zip_common<zip_shortest<Iters...>, typename ZipTupleType<Iters...>::type,
+                 Iters...> {
+  using zip_common<zip_shortest, typename ZipTupleType<Iters...>::type,
+                   Iters...>::zip_common;
+
+  bool operator==(const zip_shortest &other) const {
+    return any_iterator_equals(other, std::index_sequence_for<Iters...>{});
   }
 
-public:
-  using Base = zip_common<zip_shortest<Iters...>, Iters...>;
+private:
+  template <size_t... Ns>
+  bool any_iterator_equals(const zip_shortest &other,
+                           std::index_sequence<Ns...>) const {
+    return ((std::get<Ns>(this->iterators) == std::get<Ns>(other.iterators)) ||
+            ...);
+  }
+};
 
-  zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
+/// Helper to obtain the iterator types for the tuple storage within `zippy`.
+template <template <typename...> class ItType, typename TupleStorageType,
+          typename IndexSequence>
+struct ZippyIteratorTuple;
+
+/// Partial specialization for non-const tuple storage.
+template <template <typename...> class ItType, typename... Args,
+          std::size_t... Ns>
+struct ZippyIteratorTuple<ItType, std::tuple<Args...>,
+                          std::index_sequence<Ns...>> {
+  using type = ItType<decltype(adl_begin(
+      std::get<Ns>(declval<std::tuple<Args...> &>())))...>;
+};
 
-  bool operator==(const zip_shortest<Iters...> &other) const {
-    return !test(other, std::index_sequence_for<Iters...>{});
-  }
+/// Partial specialization for const tuple storage.
+template <template <typename...> class ItType, typename... Args,
+          std::size_t... Ns>
+struct ZippyIteratorTuple<ItType, const std::tuple<Args...>,
+                          std::index_sequence<Ns...>> {
+  using type = ItType<decltype(adl_begin(
+      std::get<Ns>(declval<const std::tuple<Args...> &>())))...>;
 };
 
 template <template <typename...> class ItType, typename... Args> class zippy {
+private:
+  std::tuple<Args...> storage;
+  using IndexSequence = std::index_sequence_for<Args...>;
+
 public:
-  using iterator = ItType<decltype(std::begin(std::declval<Args>()))...>;
+  using iterator = typename ZippyIteratorTuple<ItType, decltype(storage),
+                                               IndexSequence>::type;
+  using const_iterator =
+      typename ZippyIteratorTuple<ItType, const decltype(storage),
+                                  IndexSequence>::type;
   using iterator_category = typename iterator::iterator_category;
   using value_type = typename iterator::value_type;
   using difference_type = typename iterator::difference_type;
   using pointer = typename iterator::pointer;
   using reference = typename iterator::reference;
+  using const_reference = typename const_iterator::reference;
 
-private:
-  std::tuple<Args...> ts;
+  zippy(Args &&...args) : storage(std::forward<Args>(args)...) {}
 
+  const_iterator begin() const { return begin_impl(IndexSequence{}); }
+  iterator begin() { return begin_impl(IndexSequence{}); }
+  const_iterator end() const { return end_impl(IndexSequence{}); }
+  iterator end() { return end_impl(IndexSequence{}); }
+
+private:
   template <size_t... Ns>
-  iterator begin_impl(std::index_sequence<Ns...>) const {
-    return iterator(std::begin(std::get<Ns>(ts))...);
+  const_iterator begin_impl(std::index_sequence<Ns...>) const {
+    return const_iterator(adl_begin(std::get<Ns>(storage))...);
   }
-  template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) const {
-    return iterator(std::end(std::get<Ns>(ts))...);
+  template <size_t... Ns> iterator begin_impl(std::index_sequence<Ns...>) {
+    return iterator(adl_begin(std::get<Ns>(storage))...);
   }
 
-public:
-  zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
-
-  iterator begin() const {
-    return begin_impl(std::index_sequence_for<Args...>{});
+  template <size_t... Ns>
+  const_iterator end_impl(std::index_sequence<Ns...>) const {
+    return const_iterator(adl_end(std::get<Ns>(storage))...);
+  }
+  template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) {
+    return iterator(adl_end(std::get<Ns>(storage))...);
   }
-  iterator end() const { return end_impl(std::index_sequence_for<Args...>{}); }
 };
 
 } // end namespace detail
 
-/// zip iterator for two or more iteratable types.
+/// zip iterator for two or more iteratable types. Iteration continues until the
+/// end of the *shortest* iteratee is reached.
 template <typename T, typename U, typename... Args>
 detail::zippy<detail::zip_shortest, T, U, Args...> zip(T &&t, U &&u,
-                                                       Args &&... args) {
+                                                       Args &&...args) {
   return detail::zippy<detail::zip_shortest, T, U, Args...>(
       std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
 }
 
+/// zip iterator that assumes that all iteratees have the same length.
+/// In builds with assertions on, this assumption is checked before the
+/// iteration starts.
+template <typename T, typename U, typename... Args>
+detail::zippy<detail::zip_first, T, U, Args...> zip_equal(T &&t, U &&u,
+                                                          Args &&...args) {
+  assert(all_equal({range_size(t), range_size(u), range_size(args)...}) &&
+         "Iteratees do not have equal length");
+  return detail::zippy<detail::zip_first, T, U, Args...>(
+      std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
+}
+
 /// zip iterator that, for the sake of efficiency, assumes the first iteratee to
-/// be the shortest.
+/// be the shortest. Iteration continues until the end of the first iteratee is
+/// reached. In builds with assertions on, we check that the assumption about
+/// the first iteratee being the shortest holds.
 template <typename T, typename U, typename... Args>
 detail::zippy<detail::zip_first, T, U, Args...> zip_first(T &&t, U &&u,
-                                                          Args &&... args) {
+                                                          Args &&...args) {
+  assert(range_size(t) <= std::min({range_size(u), range_size(args)...}) &&
+         "First iteratee is not the shortest");
+
   return detail::zippy<detail::zip_first, T, U, Args...>(
       std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
 }
@@ -740,17 +891,16 @@ Iter next_or_end(const Iter &I, const Iter &End) {
 }
 
 template <typename Iter>
-auto deref_or_none(const Iter &I, const Iter &End) -> llvm::Optional<
+auto deref_or_none(const Iter &I, const Iter &End) -> std::optional<
     std::remove_const_t<std::remove_reference_t<decltype(*I)>>> {
   if (I == End)
-    return None;
+    return std::nullopt;
   return *I;
 }
 
 template <typename Iter> struct ZipLongestItemType {
-  using type =
-      llvm::Optional<typename std::remove_const<typename std::remove_reference<
-          decltype(*std::declval<Iter>())>::type>::type>;
+  using type = std::optional<std::remove_const_t<
+      std::remove_reference_t<decltype(*std::declval<Iter>())>>>;
 };
 
 template <typename... Iters> struct ZipLongestTupleType {
@@ -761,12 +911,12 @@ template <typename... Iters>
 class zip_longest_iterator
     : public iterator_facade_base<
           zip_longest_iterator<Iters...>,
-          typename std::common_type<
+          std::common_type_t<
               std::forward_iterator_tag,
-              typename std::iterator_traits<Iters>::iterator_category...>::type,
+              typename std::iterator_traits<Iters>::iterator_category...>,
           typename ZipLongestTupleType<Iters...>::type,
-          typename std::iterator_traits<typename std::tuple_element<
-              0, std::tuple<Iters...>>::type>::difference_type,
+          typename std::iterator_traits<
+              std::tuple_element_t<0, std::tuple<Iters...>>>::difference_type,
           typename ZipLongestTupleType<Iters...>::type *,
           typename ZipLongestTupleType<Iters...>::type> {
 public:
@@ -779,10 +929,8 @@ class zip_longest_iterator
   template <size_t... Ns>
   bool test(const zip_longest_iterator<Iters...> &other,
             std::index_sequence<Ns...>) const {
-    return llvm::any_of(
-        std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
-                                    std::get<Ns>(other.iterators)...},
-        identity<bool>{});
+    return ((std::get<Ns>(this->iterators) != std::get<Ns>(other.iterators)) ||
+            ...);
   }
 
   template <size_t... Ns> value_type deref(std::index_sequence<Ns...>) const {
@@ -801,8 +949,6 @@ class zip_longest_iterator
       : iterators(std::forward<Iters>(ts.first)...),
         end_iterators(std::forward<Iters>(ts.second)...) {}
 
-  value_type operator*() { return deref(std::index_sequence_for<Iters...>{}); }
-
   value_type operator*() const {
     return deref(std::index_sequence_for<Iters...>{});
   }
@@ -852,7 +998,7 @@ template <typename... Args> class zip_longest_range {
 } // namespace detail
 
 /// Iterate over two or more iterators at the same time. Iteration continues
-/// until all iterators reach the end. The llvm::Optional only contains a value
+/// until all iterators reach the end. The std::optional only contains a value
 /// if the iterator has not reached the end.
 template <typename T, typename U, typename... Args>
 detail::zip_longest_range<T, U, Args...> zip_longest(T &&t, U &&u,
@@ -986,20 +1132,39 @@ template <typename ValueT, typename... RangeTs> class concat_range {
 private:
   std::tuple<RangeTs...> Ranges;
 
-  template <size_t... Ns> iterator begin_impl(std::index_sequence<Ns...>) {
+  template <size_t... Ns>
+  iterator begin_impl(std::index_sequence<Ns...>) {
+    return iterator(std::get<Ns>(Ranges)...);
+  }
+  template <size_t... Ns>
+  iterator begin_impl(std::index_sequence<Ns...>) const {
     return iterator(std::get<Ns>(Ranges)...);
   }
   template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) {
     return iterator(make_range(std::end(std::get<Ns>(Ranges)),
                                std::end(std::get<Ns>(Ranges)))...);
   }
+  template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) const {
+    return iterator(make_range(std::end(std::get<Ns>(Ranges)),
+                               std::end(std::get<Ns>(Ranges)))...);
+  }
 
 public:
   concat_range(RangeTs &&... Ranges)
       : Ranges(std::forward<RangeTs>(Ranges)...) {}
 
-  iterator begin() { return begin_impl(std::index_sequence_for<RangeTs...>{}); }
-  iterator end() { return end_impl(std::index_sequence_for<RangeTs...>{}); }
+  iterator begin() {
+    return begin_impl(std::index_sequence_for<RangeTs...>{});
+  }
+  iterator begin() const {
+    return begin_impl(std::index_sequence_for<RangeTs...>{});
+  }
+  iterator end() {
+    return end_impl(std::index_sequence_for<RangeTs...>{});
+  }
+  iterator end() const {
+    return end_impl(std::index_sequence_for<RangeTs...>{});
+  }
 };
 
 } // end namespace detail
@@ -1073,8 +1238,7 @@ template <typename DerivedT, typename BaseT, typename T,
           typename PointerT = T *, typename ReferenceT = T &>
 class indexed_accessor_range_base {
 public:
-  using RangeBaseT =
-      indexed_accessor_range_base<DerivedT, BaseT, T, PointerT, ReferenceT>;
+  using RangeBaseT = indexed_accessor_range_base;
 
   /// An iterator element of this range.
   class iterator : public indexed_accessor_iterator<iterator, BaseT, T,
@@ -1087,8 +1251,7 @@ class indexed_accessor_range_base {
 
   private:
     iterator(BaseT owner, ptrdiff_t curIndex)
-        : indexed_accessor_iterator<iterator, BaseT, T, PointerT, ReferenceT>(
-              owner, curIndex) {}
+        : iterator::indexed_accessor_iterator(owner, curIndex) {}
 
     /// Allow access to the constructor.
     friend indexed_accessor_range_base<DerivedT, BaseT, T, PointerT,
@@ -1118,16 +1281,6 @@ class indexed_accessor_range_base {
     return (*this)[size() - 1];
   }
 
-  /// Compare this range with another.
-  template <typename OtherT> bool operator==(const OtherT &other) const {
-    return size() ==
-               static_cast<size_t>(std::distance(other.begin(), other.end())) &&
-           std::equal(begin(), end(), other.begin());
-  }
-  template <typename OtherT> bool operator!=(const OtherT &other) const {
-    return !(*this == other);
-  }
-
   /// Return the size of this range.
   size_t size() const { return count; }
 
@@ -1190,6 +1343,23 @@ class indexed_accessor_range_base {
   /// The size from the owning range.
   ptrdiff_t count;
 };
+/// Compare this range with another.
+/// FIXME: Make me a member function instead of friend when it works in C++20.
+template <typename OtherT, typename DerivedT, typename BaseT, typename T,
+          typename PointerT, typename ReferenceT>
+bool operator==(const indexed_accessor_range_base<DerivedT, BaseT, T, PointerT,
+                                                  ReferenceT> &lhs,
+                const OtherT &rhs) {
+  return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+}
+
+template <typename OtherT, typename DerivedT, typename BaseT, typename T,
+          typename PointerT, typename ReferenceT>
+bool operator!=(const indexed_accessor_range_base<DerivedT, BaseT, T, PointerT,
+                                                  ReferenceT> &lhs,
+                const OtherT &rhs) {
+  return !(lhs == rhs);
+}
 } // end namespace detail
 
 /// This class provides an implementation of a range of
@@ -1234,20 +1404,38 @@ class indexed_accessor_range
   }
 };
 
+namespace detail {
+/// Return a reference to the first or second member of a reference. Otherwise,
+/// return a copy of the member of a temporary.
+///
+/// When passing a range whose iterators return values instead of references,
+/// the reference must be dropped from `decltype((elt.first))`, which will
+/// always be a reference, to avoid returning a reference to a temporary.
+template <typename EltTy, typename FirstTy> class first_or_second_type {
+public:
+  using type = std::conditional_t<std::is_reference<EltTy>::value, FirstTy,
+                                  std::remove_reference_t<FirstTy>>;
+};
+} // end namespace detail
+
 /// Given a container of pairs, return a range over the first elements.
 template <typename ContainerTy> auto make_first_range(ContainerTy &&c) {
-  return llvm::map_range(
-      std::forward<ContainerTy>(c),
-      [](decltype((*std::begin(c))) elt) -> decltype((elt.first)) {
-        return elt.first;
-      });
+  using EltTy = decltype((*std::begin(c)));
+  return llvm::map_range(std::forward<ContainerTy>(c),
+                         [](EltTy elt) -> typename detail::first_or_second_type<
+                                           EltTy, decltype((elt.first))>::type {
+                           return elt.first;
+                         });
 }
 
 /// Given a container of pairs, return a range over the second elements.
 template <typename ContainerTy> auto make_second_range(ContainerTy &&c) {
+  using EltTy = decltype((*std::begin(c)));
   return llvm::map_range(
       std::forward<ContainerTy>(c),
-      [](decltype((*std::begin(c))) elt) -> decltype((elt.second)) {
+      [](EltTy elt) ->
+      typename detail::first_or_second_type<EltTy,
+                                            decltype((elt.second))>::type {
         return elt.second;
       });
 }
@@ -1256,19 +1444,21 @@ template <typename ContainerTy> auto make_second_range(ContainerTy &&c) {
 //     Extra additions to <utility>
 //===----------------------------------------------------------------------===//
 
-/// Function object to check whether the first component of a std::pair
-/// compares less than the first component of another std::pair.
+/// Function object to check whether the first component of a container
+/// supported by std::get (like std::pair and std::tuple) compares less than the
+/// first component of another container.
 struct less_first {
   template <typename T> bool operator()(const T &lhs, const T &rhs) const {
-    return lhs.first < rhs.first;
+    return std::less<>()(std::get<0>(lhs), std::get<0>(rhs));
   }
 };
 
-/// Function object to check whether the second component of a std::pair
-/// compares less than the second component of another std::pair.
+/// Function object to check whether the second component of a container
+/// supported by std::get (like std::pair and std::tuple) compares less than the
+/// second component of another container.
 struct less_second {
   template <typename T> bool operator()(const T &lhs, const T &rhs) const {
-    return lhs.second < rhs.second;
+    return std::less<>()(std::get<1>(lhs), std::get<1>(rhs));
   }
 };
 
@@ -1289,16 +1479,6 @@ struct on_first {
 template <int N> struct rank : rank<N - 1> {};
 template <> struct rank<0> {};
 
-/// traits class for checking whether type T is one of any of the given
-/// types in the variadic list.
-template <typename T, typename... Ts>
-using is_one_of = disjunction<std::is_same<T, Ts>...>;
-
-/// traits class for checking whether type T is a base class for all
-///  the given types in the variadic list.
-template <typename T, typename... Ts>
-using are_base_of = conjunction<std::is_base_of<T, Ts>...>;
-
 namespace detail {
 template <typename... Ts> struct Visitor;
 
@@ -1352,7 +1532,7 @@ constexpr decltype(auto) makeVisitor(CallableTs &&...Callables) {
 }
 
 //===----------------------------------------------------------------------===//
-//     Extra additions for arrays
+//     Extra additions to <algorithm>
 //===----------------------------------------------------------------------===//
 
 // We have a copy here so that LLVM behaves the same when using different
@@ -1372,12 +1552,6 @@ void shuffle(Iterator first, Iterator last, RNG &&g) {
   }
 }
 
-/// Find the length of an array.
-template <class T, std::size_t N>
-constexpr inline size_t array_lengthof(T (&)[N]) {
-  return N;
-}
-
 /// Adapt std::less<T> for array_pod_sort.
 template<typename T>
 inline int array_pod_sort_comparator(const void *P1, const void *P2) {
@@ -1462,30 +1636,25 @@ namespace detail {
 template <typename T>
 // We can use qsort if the iterator type is a pointer and the underlying value
 // is trivially copyable.
-using sort_trivially_copyable = conjunction<
+using sort_trivially_copyable = std::conjunction<
     std::is_pointer<T>,
     std::is_trivially_copyable<typename std::iterator_traits<T>::value_type>>;
 } // namespace detail
 
 // Provide wrappers to std::sort which shuffle the elements before sorting
 // to help uncover non-deterministic behavior (PR35135).
-template <typename IteratorTy,
-          std::enable_if_t<!detail::sort_trivially_copyable<IteratorTy>::value,
-                           int> = 0>
+template <typename IteratorTy>
 inline void sort(IteratorTy Start, IteratorTy End) {
+  if constexpr (detail::sort_trivially_copyable<IteratorTy>::value) {
+    // Forward trivially copyable types to array_pod_sort. This avoids a large
+    // amount of code bloat for a minor performance hit.
+    array_pod_sort(Start, End);
+  } else {
 #ifdef EXPENSIVE_CHECKS
-  detail::presortShuffle<IteratorTy>(Start, End);
+    detail::presortShuffle<IteratorTy>(Start, End);
 #endif
-  std::sort(Start, End);
-}
-
-// Forward trivially copyable types to array_pod_sort. This avoids a large
-// amount of code bloat for a minor performance hit.
-template <typename IteratorTy,
-          std::enable_if_t<detail::sort_trivially_copyable<IteratorTy>::value,
-                           int> = 0>
-inline void sort(IteratorTy Start, IteratorTy End) {
-  array_pod_sort(Start, End);
+    std::sort(Start, End);
+  }
 }
 
 template <typename Container> inline void sort(Container &&C) {
@@ -1505,10 +1674,6 @@ inline void sort(Container &&C, Compare Comp) {
   llvm::sort(adl_begin(C), adl_end(C), Comp);
 }
 
-//===----------------------------------------------------------------------===//
-//     Extra additions to <algorithm>
-//===----------------------------------------------------------------------===//
-
 /// Get the size of a range. This is a wrapper function around std::distance
 /// which is only enabled when the operation is O(1).
 template <typename R>
@@ -1521,6 +1686,29 @@ auto size(R &&Range,
   return std::distance(Range.begin(), Range.end());
 }
 
+namespace detail {
+template <typename Range>
+using check_has_free_function_size =
+    decltype(adl_size(std::declval<Range &>()));
+
+template <typename Range>
+static constexpr bool HasFreeFunctionSize =
+    is_detected<check_has_free_function_size, Range>::value;
+} // namespace detail
+
+/// Returns the size of the \p Range, i.e., the number of elements. This
+/// implementation takes inspiration from `std::ranges::size` from C++20 and
+/// delegates the size check to `adl_size` or `std::distance`, in this order of
+/// preference. Unlike `llvm::size`, this function does *not* guarantee O(1)
+/// running time, and is intended to be used in generic code that does not know
+/// the exact range type.
+template <typename R> constexpr size_t range_size(R &&Range) {
+  if constexpr (detail::HasFreeFunctionSize<R>)
+    return adl_size(Range);
+  else
+    return static_cast<size_t>(std::distance(adl_begin(Range), adl_end(Range)));
+}
+
 /// Provide wrappers to std::for_each which take ranges instead of having to
 /// pass begin/end explicitly.
 template <typename R, typename UnaryFunction>
@@ -1581,11 +1769,80 @@ OutputIt copy_if(R &&Range, OutputIt Out, UnaryPredicate P) {
   return std::copy_if(adl_begin(Range), adl_end(Range), Out, P);
 }
 
+/// Return the single value in \p Range that satisfies
+/// \p P(<member of \p Range> *, AllowRepeats)->T * returning nullptr
+/// when no values or multiple values were found.
+/// When \p AllowRepeats is true, multiple values that compare equal
+/// are allowed.
+template <typename T, typename R, typename Predicate>
+T *find_singleton(R &&Range, Predicate P, bool AllowRepeats = false) {
+  T *RC = nullptr;
+  for (auto &&A : Range) {
+    if (T *PRC = P(A, AllowRepeats)) {
+      if (RC) {
+        if (!AllowRepeats || PRC != RC)
+          return nullptr;
+      } else
+        RC = PRC;
+    }
+  }
+  return RC;
+}
+
+/// Return a pair consisting of the single value in \p Range that satisfies
+/// \p P(<member of \p Range> *, AllowRepeats)->std::pair<T*, bool> returning
+/// nullptr when no values or multiple values were found, and a bool indicating
+/// whether multiple values were found to cause the nullptr.
+/// When \p AllowRepeats is true, multiple values that compare equal are
+/// allowed.  The predicate \p P returns a pair<T *, bool> where T is the
+/// singleton while the bool indicates whether multiples have already been
+/// found.  It is expected that first will be nullptr when second is true.
+/// This allows using find_singleton_nested within the predicate \P.
+template <typename T, typename R, typename Predicate>
+std::pair<T *, bool> find_singleton_nested(R &&Range, Predicate P,
+                                           bool AllowRepeats = false) {
+  T *RC = nullptr;
+  for (auto *A : Range) {
+    std::pair<T *, bool> PRC = P(A, AllowRepeats);
+    if (PRC.second) {
+      assert(PRC.first == nullptr &&
+             "Inconsistent return values in find_singleton_nested.");
+      return PRC;
+    }
+    if (PRC.first) {
+      if (RC) {
+        if (!AllowRepeats || PRC.first != RC)
+          return {nullptr, true};
+      } else
+        RC = PRC.first;
+    }
+  }
+  return {RC, false};
+}
+
 template <typename R, typename OutputIt>
 OutputIt copy(R &&Range, OutputIt Out) {
   return std::copy(adl_begin(Range), adl_end(Range), Out);
 }
 
+/// Provide wrappers to std::replace_copy_if which take ranges instead of having
+/// to pass begin/end explicitly.
+template <typename R, typename OutputIt, typename UnaryPredicate, typename T>
+OutputIt replace_copy_if(R &&Range, OutputIt Out, UnaryPredicate P,
+                         const T &NewValue) {
+  return std::replace_copy_if(adl_begin(Range), adl_end(Range), Out, P,
+                              NewValue);
+}
+
+/// Provide wrappers to std::replace_copy which take ranges instead of having to
+/// pass begin/end explicitly.
+template <typename R, typename OutputIt, typename T>
+OutputIt replace_copy(R &&Range, OutputIt Out, const T &OldValue,
+                      const T &NewValue) {
+  return std::replace_copy(adl_begin(Range), adl_end(Range), Out, OldValue,
+                           NewValue);
+}
+
 /// Provide wrappers to std::move which take ranges instead of having to
 /// pass begin/end explicitly.
 template <typename R, typename OutputIt>
@@ -1593,11 +1850,51 @@ OutputIt move(R &&Range, OutputIt Out) {
   return std::move(adl_begin(Range), adl_end(Range), Out);
 }
 
-/// Wrapper function around std::find to detect if an element exists
-/// in a container.
+namespace detail {
+template <typename Range, typename Element>
+using check_has_member_contains_t =
+    decltype(std::declval<Range &>().contains(std::declval<const Element &>()));
+
+template <typename Range, typename Element>
+static constexpr bool HasMemberContains =
+    is_detected<check_has_member_contains_t, Range, Element>::value;
+
+template <typename Range, typename Element>
+using check_has_member_find_t =
+    decltype(std::declval<Range &>().find(std::declval<const Element &>()) !=
+             std::declval<Range &>().end());
+
+template <typename Range, typename Element>
+static constexpr bool HasMemberFind =
+    is_detected<check_has_member_find_t, Range, Element>::value;
+
+} // namespace detail
+
+/// Returns true if \p Element is found in \p Range. Delegates the check to
+/// either `.contains(Element)`, `.find(Element)`, or `std::find`, in this
+/// order of preference. This is intended as the canonical way to check if an
+/// element exists in a range in generic code or range type that does not
+/// expose a `.contains(Element)` member.
 template <typename R, typename E>
 bool is_contained(R &&Range, const E &Element) {
-  return std::find(adl_begin(Range), adl_end(Range), Element) != adl_end(Range);
+  if constexpr (detail::HasMemberContains<R, E>)
+    return Range.contains(Element);
+  else if constexpr (detail::HasMemberFind<R, E>)
+    return Range.find(Element) != Range.end();
+  else
+    return std::find(adl_begin(Range), adl_end(Range), Element) !=
+           adl_end(Range);
+}
+
+/// Returns true iff \p Element exists in \p Set. This overload takes \p Set as
+/// an initializer list and is `constexpr`-friendly.
+template <typename T, typename E>
+constexpr bool is_contained(std::initializer_list<T> Set, const E &Element) {
+  // TODO: Use std::find when we switch to C++20.
+  for (const T &V : Set)
+    if (V == Element)
+      return true;
+  return false;
 }
 
 /// Wrapper function around std::is_sorted to check if elements in a range \p R
@@ -1639,6 +1936,19 @@ auto partition(R &&Range, UnaryPredicate P) {
   return std::partition(adl_begin(Range), adl_end(Range), P);
 }
 
+/// Provide wrappers to std::binary_search which take ranges instead of having
+/// to pass begin/end explicitly.
+template <typename R, typename T> auto binary_search(R &&Range, T &&Value) {
+  return std::binary_search(adl_begin(Range), adl_end(Range),
+                            std::forward<T>(Value));
+}
+
+template <typename R, typename T, typename Compare>
+auto binary_search(R &&Range, T &&Value, Compare C) {
+  return std::binary_search(adl_begin(Range), adl_end(Range),
+                            std::forward<T>(Value), C);
+}
+
 /// Provide wrappers to std::lower_bound which take ranges instead of having to
 /// pass begin/end explicitly.
 template <typename R, typename T> auto lower_bound(R &&Range, T &&Value) {
@@ -1665,6 +1975,22 @@ auto upper_bound(R &&Range, T &&Value, Compare C) {
                           std::forward<T>(Value), C);
 }
 
+template <typename R> auto min_element(R &&Range) {
+  return std::min_element(adl_begin(Range), adl_end(Range));
+}
+
+template <typename R, typename Compare> auto min_element(R &&Range, Compare C) {
+  return std::min_element(adl_begin(Range), adl_end(Range), C);
+}
+
+template <typename R> auto max_element(R &&Range) {
+  return std::max_element(adl_begin(Range), adl_end(Range));
+}
+
+template <typename R, typename Compare> auto max_element(R &&Range, Compare C) {
+  return std::max_element(adl_begin(Range), adl_end(Range), C);
+}
+
 template <typename R>
 void stable_sort(R &&Range) {
   std::stable_sort(adl_begin(Range), adl_end(Range));
@@ -1688,13 +2014,36 @@ auto unique(Range &&R, Predicate P) {
   return std::unique(adl_begin(R), adl_end(R), P);
 }
 
-/// Wrapper function around std::equal to detect if all elements
-/// in a container are same.
-template <typename R>
-bool is_splat(R &&Range) {
-  size_t range_size = size(Range);
-  return range_size != 0 && (range_size == 1 ||
-         std::equal(adl_begin(Range) + 1, adl_end(Range), adl_begin(Range)));
+/// Wrapper function around std::unique to allow calling unique on a
+/// container without having to specify the begin/end iterators.
+template <typename Range> auto unique(Range &&R) {
+  return std::unique(adl_begin(R), adl_end(R));
+}
+
+/// Wrapper function around std::equal to detect if pair-wise elements between
+/// two ranges are the same.
+template <typename L, typename R> bool equal(L &&LRange, R &&RRange) {
+  return std::equal(adl_begin(LRange), adl_end(LRange), adl_begin(RRange),
+                    adl_end(RRange));
+}
+
+template <typename L, typename R, typename BinaryPredicate>
+bool equal(L &&LRange, R &&RRange, BinaryPredicate P) {
+  return std::equal(adl_begin(LRange), adl_end(LRange), adl_begin(RRange),
+                    adl_end(RRange), P);
+}
+
+/// Returns true if all elements in Range are equal or when the Range is empty.
+template <typename R> bool all_equal(R &&Range) {
+  auto Begin = adl_begin(Range);
+  auto End = adl_end(Range);
+  return Begin == End || std::equal(Begin + 1, End, Begin);
+}
+
+/// Returns true if all Values in the initializer lists are equal or the list
+// is empty.
+template <typename T> bool all_equal(std::initializer_list<T> Values) {
+  return all_equal<std::initializer_list<T>>(std::move(Values));
 }
 
 /// Provide a container algorithm similar to C++ Library Fundamentals v2's
@@ -1713,16 +2062,24 @@ void erase_if(Container &C, UnaryPredicate P) {
 ///
 /// C.erase(remove(C.begin(), C.end(), V), C.end());
 template <typename Container, typename ValueType>
-void erase_value(Container &C, ValueType V) {
+void erase(Container &C, ValueType V) {
   C.erase(std::remove(C.begin(), C.end(), V), C.end());
 }
 
-/// Wrapper function to append a range to a container.
+/// Wrapper function to append range `R` to container `C`.
 ///
 /// C.insert(C.end(), R.begin(), R.end());
 template <typename Container, typename Range>
-inline void append_range(Container &C, Range &&R) {
-  C.insert(C.end(), R.begin(), R.end());
+void append_range(Container &C, Range &&R) {
+  C.insert(C.end(), adl_begin(R), adl_end(R));
+}
+
+/// Appends all `Values` to container `C`.
+template <typename Container, typename... Args>
+void append_values(Container &C, Args &&...Values) {
+  C.reserve(range_size(C) + sizeof...(Args));
+  // Append all values one by one.
+  ((void)C.insert(C.end(), std::forward<Args>(Values)), ...);
 }
 
 /// Given a sequence container Cont, replace the range [ContIt, ContEnd) with
@@ -1764,9 +2121,9 @@ void replace(Container &Cont, typename Container::iterator ContIt,
 /// \endcode
 template <typename ForwardIterator, typename UnaryFunctor,
           typename NullaryFunctor,
-          typename = typename std::enable_if<
+          typename = std::enable_if_t<
               !std::is_constructible<StringRef, UnaryFunctor>::value &&
-              !std::is_constructible<StringRef, NullaryFunctor>::value>::type>
+              !std::is_constructible<StringRef, NullaryFunctor>::value>>
 inline void interleave(ForwardIterator begin, ForwardIterator end,
                        UnaryFunctor each_fn, NullaryFunctor between_fn) {
   if (begin == end)
@@ -1780,12 +2137,12 @@ inline void interleave(ForwardIterator begin, ForwardIterator end,
 }
 
 template <typename Container, typename UnaryFunctor, typename NullaryFunctor,
-          typename = typename std::enable_if<
+          typename = std::enable_if_t<
               !std::is_constructible<StringRef, UnaryFunctor>::value &&
-              !std::is_constructible<StringRef, NullaryFunctor>::value>::type>
+              !std::is_constructible<StringRef, NullaryFunctor>::value>>
 inline void interleave(const Container &c, UnaryFunctor each_fn,
                        NullaryFunctor between_fn) {
-  interleave(c.begin(), c.end(), each_fn, between_fn);
+  interleave(adl_begin(c), adl_end(c), each_fn, between_fn);
 }
 
 /// Overload of interleave for the common case of string separator.
@@ -1793,7 +2150,7 @@ template <typename Container, typename UnaryFunctor, typename StreamT,
           typename T = detail::ValueOfRange<Container>>
 inline void interleave(const Container &c, StreamT &os, UnaryFunctor each_fn,
                        const StringRef &separator) {
-  interleave(c.begin(), c.end(), each_fn, [&] { os << separator; });
+  interleave(adl_begin(c), adl_end(c), each_fn, [&] { os << separator; });
 }
 template <typename Container, typename StreamT,
           typename T = detail::ValueOfRange<Container>>
@@ -1849,134 +2206,255 @@ template <typename T> struct deref {
 
 namespace detail {
 
-template <typename R> class enumerator_iter;
-
-template <typename R> struct result_pair {
-  using value_reference =
-      typename std::iterator_traits<IterOfRange<R>>::reference;
+/// Tuple-like type for `zip_enumerator` dereference.
+template <typename... Refs> struct enumerator_result;
 
-  friend class enumerator_iter<R>;
-
-  result_pair() = default;
-  result_pair(std::size_t Index, IterOfRange<R> Iter)
-      : Index(Index), Iter(Iter) {}
+template <typename... Iters>
+using EnumeratorTupleType = enumerator_result<decltype(*declval<Iters>())...>;
+
+/// Zippy iterator that uses the second iterator for comparisons. For the
+/// increment to be safe, the second range has to be the shortest.
+/// Returns `enumerator_result` on dereference to provide `.index()` and
+/// `.value()` member functions.
+/// Note: Because the dereference operator returns `enumerator_result` as a
+/// value instead of a reference and does not strictly conform to the C++17's
+/// definition of forward iterator. However, it satisfies all the
+/// forward_iterator requirements that the `zip_common` and `zippy` depend on
+/// and fully conforms to the C++20 definition of forward iterator.
+/// This is similar to `std::vector<bool>::iterator` that returns bit reference
+/// wrappers on dereference.
+template <typename... Iters>
+struct zip_enumerator : zip_common<zip_enumerator<Iters...>,
+                                   EnumeratorTupleType<Iters...>, Iters...> {
+  static_assert(sizeof...(Iters) >= 2, "Expected at least two iteratees");
+  using zip_common<zip_enumerator<Iters...>, EnumeratorTupleType<Iters...>,
+                   Iters...>::zip_common;
 
-  result_pair(const result_pair<R> &Other)
-      : Index(Other.Index), Iter(Other.Iter) {}
-  result_pair &operator=(const result_pair &Other) {
-    Index = Other.Index;
-    Iter = Other.Iter;
-    return *this;
+  bool operator==(const zip_enumerator &Other) const {
+    return std::get<1>(this->iterators) == std::get<1>(Other.iterators);
   }
+};
 
-  std::size_t index() const { return Index; }
-  const value_reference value() const { return *Iter; }
-  value_reference value() { return *Iter; }
+template <typename... Refs> struct enumerator_result<std::size_t, Refs...> {
+  static constexpr std::size_t NumRefs = sizeof...(Refs);
+  static_assert(NumRefs != 0);
+  // `NumValues` includes the index.
+  static constexpr std::size_t NumValues = NumRefs + 1;
+
+  // Tuple type whose element types are references for each `Ref`.
+  using range_reference_tuple = std::tuple<Refs...>;
+  // Tuple type who elements are references to all values, including both
+  // the index and `Refs` reference types.
+  using value_reference_tuple = std::tuple<std::size_t, Refs...>;
+
+  enumerator_result(std::size_t Index, Refs &&...Rs)
+      : Idx(Index), Storage(std::forward<Refs>(Rs)...) {}
+
+  /// Returns the 0-based index of the current position within the original
+  /// input range(s).
+  std::size_t index() const { return Idx; }
+
+  /// Returns the value(s) for the current iterator. This does not include the
+  /// index.
+  decltype(auto) value() const {
+    if constexpr (NumRefs == 1)
+      return std::get<0>(Storage);
+    else
+      return Storage;
+  }
+
+  /// Returns the value at index `I`. This case covers the index.
+  template <std::size_t I, typename = std::enable_if_t<I == 0>>
+  friend std::size_t get(const enumerator_result &Result) {
+    return Result.Idx;
+  }
+
+  /// Returns the value at index `I`. This case covers references to the
+  /// iteratees.
+  template <std::size_t I, typename = std::enable_if_t<I != 0>>
+  friend decltype(auto) get(const enumerator_result &Result) {
+    // Note: This is a separate function from the other `get`, instead of an
+    // `if constexpr` case, to work around an MSVC 19.31.31XXX compiler
+    // (Visual Studio 2022 17.1) return type deduction bug.
+    return std::get<I - 1>(Result.Storage);
+  }
+
+  template <typename... Ts>
+  friend bool operator==(const enumerator_result &Result,
+                         const std::tuple<std::size_t, Ts...> &Other) {
+    static_assert(NumRefs == sizeof...(Ts), "Size mismatch");
+    if (Result.Idx != std::get<0>(Other))
+      return false;
+    return Result.is_value_equal(Other, std::make_index_sequence<NumRefs>{});
+  }
 
 private:
-  std::size_t Index = std::numeric_limits<std::size_t>::max();
-  IterOfRange<R> Iter;
+  template <typename Tuple, std::size_t... Idx>
+  bool is_value_equal(const Tuple &Other, std::index_sequence<Idx...>) const {
+    return ((std::get<Idx>(Storage) == std::get<Idx + 1>(Other)) && ...);
+  }
+
+  std::size_t Idx;
+  // Make this tuple mutable to avoid casts that obfuscate const-correctness
+  // issues. Const-correctness of references is taken care of by `zippy` that
+  // defines const-non and const iterator types that will propagate down to
+  // `enumerator_result`'s `Refs`.
+  //  Note that unlike the results of `zip*` functions, `enumerate`'s result are
+  //  supposed to be modifiable even when defined as
+  // `const`.
+  mutable range_reference_tuple Storage;
 };
 
-template <typename R>
-class enumerator_iter
-    : public iterator_facade_base<
-          enumerator_iter<R>, std::forward_iterator_tag, result_pair<R>,
-          typename std::iterator_traits<IterOfRange<R>>::difference_type,
-          typename std::iterator_traits<IterOfRange<R>>::pointer,
-          typename std::iterator_traits<IterOfRange<R>>::reference> {
-  using result_type = result_pair<R>;
-
-public:
-  explicit enumerator_iter(IterOfRange<R> EndIter)
-      : Result(std::numeric_limits<size_t>::max(), EndIter) {}
-
-  enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
-      : Result(Index, Iter) {}
+struct index_iterator
+    : llvm::iterator_facade_base<index_iterator,
+                                 std::random_access_iterator_tag, std::size_t> {
+  index_iterator(std::size_t Index) : Index(Index) {}
 
-  result_type &operator*() { return Result; }
-  const result_type &operator*() const { return Result; }
-
-  enumerator_iter &operator++() {
-    assert(Result.Index != std::numeric_limits<size_t>::max());
-    ++Result.Iter;
-    ++Result.Index;
+  index_iterator &operator+=(std::ptrdiff_t N) {
+    Index += N;
     return *this;
   }
 
-  bool operator==(const enumerator_iter &RHS) const {
-    // Don't compare indices here, only iterators.  It's possible for an end
-    // iterator to have different indices depending on whether it was created
-    // by calling std::end() versus incrementing a valid iterator.
-    return Result.Iter == RHS.Result.Iter;
-  }
-
-  enumerator_iter(const enumerator_iter &Other) : Result(Other.Result) {}
-  enumerator_iter &operator=(const enumerator_iter &Other) {
-    Result = Other.Result;
+  index_iterator &operator-=(std::ptrdiff_t N) {
+    Index -= N;
     return *this;
   }
 
-private:
-  result_type Result;
-};
+  std::ptrdiff_t operator-(const index_iterator &R) const {
+    return Index - R.Index;
+  }
 
-template <typename R> class enumerator {
-public:
-  explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
+  // Note: This dereference operator returns a value instead of a reference
+  // and does not strictly conform to the C++17's definition of forward
+  // iterator. However, it satisfies all the forward_iterator requirements
+  // that the `zip_common` depends on and fully conforms to the C++20
+  // definition of forward iterator.
+  std::size_t operator*() const { return Index; }
 
-  enumerator_iter<R> begin() {
-    return enumerator_iter<R>(0, std::begin(TheRange));
+  friend bool operator==(const index_iterator &Lhs, const index_iterator &Rhs) {
+    return Lhs.Index == Rhs.Index;
   }
 
-  enumerator_iter<R> end() {
-    return enumerator_iter<R>(std::end(TheRange));
+  friend bool operator<(const index_iterator &Lhs, const index_iterator &Rhs) {
+    return Lhs.Index < Rhs.Index;
   }
 
 private:
-  R TheRange;
+  std::size_t Index;
+};
+
+/// Infinite stream of increasing 0-based `size_t` indices.
+struct index_stream {
+  index_iterator begin() const { return {0}; }
+  index_iterator end() const {
+    // We approximate 'infinity' with the max size_t value, which should be good
+    // enough to index over any container.
+    return index_iterator{std::numeric_limits<std::size_t>::max()};
+  }
 };
 
 } // end namespace detail
 
-/// Given an input range, returns a new range whose values are are pair (A,B)
-/// such that A is the 0-based index of the item in the sequence, and B is
-/// the value from the original sequence.  Example:
+/// Increasing range of `size_t` indices.
+class index_range {
+  std::size_t Begin;
+  std::size_t End;
+
+public:
+  index_range(std::size_t Begin, std::size_t End) : Begin(Begin), End(End) {}
+  detail::index_iterator begin() const { return {Begin}; }
+  detail::index_iterator end() const { return {End}; }
+};
+
+/// Given two or more input ranges, returns a new range whose values are are
+/// tuples (A, B, C, ...), such that A is the 0-based index of the item in the
+/// sequence, and B, C, ..., are the values from the original input ranges. All
+/// input ranges are required to have equal lengths. Note that the returned
+/// iterator allows for the values (B, C, ...) to be modified.  Example:
+///
+/// ```c++
+/// std::vector<char> Letters = {'A', 'B', 'C', 'D'};
+/// std::vector<int> Vals = {10, 11, 12, 13};
+///
+/// for (auto [Index, Letter, Value] : enumerate(Letters, Vals)) {
+///   printf("Item %zu - %c: %d\n", Index, Letter, Value);
+///   Value -= 10;
+/// }
+/// ```
+///
+/// Output:
+///   Item 0 - A: 10
+///   Item 1 - B: 11
+///   Item 2 - C: 12
+///   Item 3 - D: 13
 ///
-/// std::vector<char> Items = {'A', 'B', 'C', 'D'};
-/// for (auto X : enumerate(Items)) {
-///   printf("Item %d - %c\n", X.index(), X.value());
+/// or using an iterator:
+/// ```c++
+/// for (auto it : enumerate(Vals)) {
+///   it.value() += 10;
+///   printf("Item %zu: %d\n", it.index(), it.value());
 /// }
+/// ```
 ///
 /// Output:
-///   Item 0 - A
-///   Item 1 - B
-///   Item 2 - C
-///   Item 3 - D
+///   Item 0: 20
+///   Item 1: 21
+///   Item 2: 22
+///   Item 3: 23
 ///
-template <typename R> detail::enumerator<R> enumerate(R &&TheRange) {
-  return detail::enumerator<R>(std::forward<R>(TheRange));
+template <typename FirstRange, typename... RestRanges>
+auto enumerate(FirstRange &&First, RestRanges &&...Rest) {
+  if constexpr (sizeof...(Rest) != 0) {
+#ifndef NDEBUG
+    // Note: Create an array instead of an initializer list to work around an
+    // Apple clang 14 compiler bug.
+    size_t sizes[] = {range_size(First), range_size(Rest)...};
+    assert(all_equal(sizes) && "Ranges have different length");
+#endif
+  }
+  using enumerator = detail::zippy<detail::zip_enumerator, detail::index_stream,
+                                   FirstRange, RestRanges...>;
+  return enumerator(detail::index_stream{}, std::forward<FirstRange>(First),
+                    std::forward<RestRanges>(Rest)...);
 }
 
 namespace detail {
 
-template <typename F, typename Tuple, std::size_t... I>
-decltype(auto) apply_tuple_impl(F &&f, Tuple &&t, std::index_sequence<I...>) {
-  return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
+template <typename Predicate, typename... Args>
+bool all_of_zip_predicate_first(Predicate &&P, Args &&...args) {
+  auto z = zip(args...);
+  auto it = z.begin();
+  auto end = z.end();
+  while (it != end) {
+    if (!std::apply([&](auto &&...args) { return P(args...); }, *it))
+      return false;
+    ++it;
+  }
+  return it.all_equals(end);
 }
 
-} // end namespace detail
+// Just an adaptor to switch the order of argument and have the predicate before
+// the zipped inputs.
+template <typename... ArgsThenPredicate, size_t... InputIndexes>
+bool all_of_zip_predicate_last(
+    std::tuple<ArgsThenPredicate...> argsThenPredicate,
+    std::index_sequence<InputIndexes...>) {
+  auto constexpr OutputIndex =
+      std::tuple_size<decltype(argsThenPredicate)>::value - 1;
+  return all_of_zip_predicate_first(std::get<OutputIndex>(argsThenPredicate),
+                             std::get<InputIndexes>(argsThenPredicate)...);
+}
 
-/// Given an input tuple (a1, a2, ..., an), pass the arguments of the
-/// tuple variadically to f as if by calling f(a1, a2, ..., an) and
-/// return the result.
-template <typename F, typename Tuple>
-decltype(auto) apply_tuple(F &&f, Tuple &&t) {
-  using Indices = std::make_index_sequence<
-      std::tuple_size<typename std::decay<Tuple>::type>::value>;
+} // end namespace detail
 
-  return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
-                                  Indices{});
+/// Compare two zipped ranges using the provided predicate (as last argument).
+/// Return true if all elements satisfy the predicate and false otherwise.
+//  Return false if the zipped iterator aren't all at end (size mismatch).
+template <typename... ArgsAndPredicate>
+bool all_of_zip(ArgsAndPredicate &&...argsAndPredicate) {
+  return detail::all_of_zip_predicate_last(
+      std::forward_as_tuple(argsAndPredicate...),
+      std::make_index_sequence<sizeof...(argsAndPredicate) - 1>{});
 }
 
 /// Return true if the sequence [Begin, End) has exactly N items. Runs in O(N)
@@ -2066,6 +2544,31 @@ bool hasNItemsOrLess(ContainerTy &&C, unsigned N) {
 template <class Ptr> auto to_address(const Ptr &P) { return P.operator->(); }
 template <class T> constexpr T *to_address(T *P) { return P; }
 
+// Detect incomplete types, relying on the fact that their size is unknown.
+namespace detail {
+template <typename T> using has_sizeof = decltype(sizeof(T));
+} // namespace detail
+
+/// Detects when type `T` is incomplete. This is true for forward declarations
+/// and false for types with a full definition.
+template <typename T>
+constexpr bool is_incomplete_v = !is_detected<detail::has_sizeof, T>::value;
+
 } // end namespace llvm
 
+namespace std {
+template <typename... Refs>
+struct tuple_size<llvm::detail::enumerator_result<Refs...>>
+    : std::integral_constant<std::size_t, sizeof...(Refs)> {};
+
+template <std::size_t I, typename... Refs>
+struct tuple_element<I, llvm::detail::enumerator_result<Refs...>>
+    : std::tuple_element<I, std::tuple<Refs...>> {};
+
+template <std::size_t I, typename... Refs>
+struct tuple_element<I, const llvm::detail::enumerator_result<Refs...>>
+    : std::tuple_element<I, std::tuple<Refs...>> {};
+
+} // namespace std
+
 #endif // LLVM_ADT_STLEXTRAS_H
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/STLForwardCompat.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/STLForwardCompat.h
index 440b29df2..6afe3610b 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/ADT/STLForwardCompat.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/ADT/STLForwardCompat.h
@@ -5,64 +5,23 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
-// This file contains library features backported from future STL versions.
-//
-// These should be replaced with their STL counterparts as the C++ version LLVM
-// is compiled with is updated.
-//
+///
+/// \file
+/// This file contains library features backported from future STL versions.
+///
+/// These should be replaced with their STL counterparts as the C++ version LLVM
+/// is compiled with is updated.
+///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_STLFORWARDCOMPAT_H
 #define LLVM_ADT_STLFORWARDCOMPAT_H
 
+#include <optional>
 #include <type_traits>
 
 namespace llvm {
 
-//===----------------------------------------------------------------------===//
-//     Features from C++17
-//===----------------------------------------------------------------------===//
-
-template <typename T>
-struct negation // NOLINT(readability-identifier-naming)
-    : std::integral_constant<bool, !bool(T::value)> {};
-
-template <typename...>
-struct conjunction // NOLINT(readability-identifier-naming)
-    : std::true_type {};
-template <typename B1> struct conjunction<B1> : B1 {};
-template <typename B1, typename... Bn>
-struct conjunction<B1, Bn...>
-    : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
-
-template <typename...>
-struct disjunction // NOLINT(readability-identifier-naming)
-    : std::false_type {};
-template <typename B1> struct disjunction<B1> : B1 {};
-template <typename B1, typename... Bn>
-struct disjunction<B1, Bn...>
-    : std::conditional<bool(B1::value), B1, disjunction<Bn...>>::type {};
-
-struct in_place_t // NOLINT(readability-identifier-naming)
-{
-  explicit in_place_t() = default;
-};
-/// \warning This must not be odr-used, as it cannot be made \c inline in C++14.
-constexpr in_place_t in_place; // NOLINT(readability-identifier-naming)
-
-template <typename T>
-struct in_place_type_t // NOLINT(readability-identifier-naming)
-{
-  explicit in_place_type_t() = default;
-};
-
-template <std::size_t I>
-struct in_place_index_t // NOLINT(readability-identifier-naming)
-{
-  explicit in_place_index_t() = default;
-};
-
 //===----------------------------------------------------------------------===//
 //     Features from C++20
 //===----------------------------------------------------------------------===//
@@ -77,6 +36,37 @@ template <typename T>
 using remove_cvref_t // NOLINT(readability-identifier-naming)
     = typename llvm::remove_cvref<T>::type;
 
+//===----------------------------------------------------------------------===//
+//     Features from C++23
+//===----------------------------------------------------------------------===//
+
+// TODO: Remove this in favor of std::optional<T>::transform once we switch to
+// C++23.
+template <typename T, typename Function>
+auto transformOptional(const std::optional<T> &O, const Function &F)
+    -> std::optional<decltype(F(*O))> {
+  if (O)
+    return F(*O);
+  return std::nullopt;
+}
+
+// TODO: Remove this in favor of std::optional<T>::transform once we switch to
+// C++23.
+template <typename T, typename Function>
+auto transformOptional(std::optional<T> &&O, const Function &F)
+    -> std::optional<decltype(F(*std::move(O)))> {
+  if (O)
+    return F(*std::move(O));
+  return std::nullopt;
+}
+
+/// Returns underlying integer value of an enum. Backport of C++23
+/// std::to_underlying.
+template <typename Enum>
+[[nodiscard]] constexpr std::underlying_type_t<Enum> to_underlying(Enum E) {
+  return static_cast<std::underlying_type_t<Enum>>(E);
+}
+
 } // namespace llvm
 
 #endif // LLVM_ADT_STLFORWARDCOMPAT_H
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/STLFunctionalExtras.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/STLFunctionalExtras.h
new file mode 100644
index 000000000..dd7fc6dc7
--- /dev/null
+++ b/symbolic-demangle/vendor/swift/include/llvm/ADT/STLFunctionalExtras.h
@@ -0,0 +1,76 @@
+//===- llvm/ADT/STLFunctionalExtras.h - Extras for <functional> -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains some extension to <functional>.
+//
+// No library is required when using these functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_STLFUNCTIONALEXTRAS_H
+#define LLVM_ADT_STLFUNCTIONALEXTRAS_H
+
+#include "llvm/ADT/STLForwardCompat.h"
+
+#include <cstdint>
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+
+//===----------------------------------------------------------------------===//
+//     Extra additions to <functional>
+//===----------------------------------------------------------------------===//
+
+/// An efficient, type-erasing, non-owning reference to a callable. This is
+/// intended for use as the type of a function parameter that is not used
+/// after the function in question returns.
+///
+/// This class does not own the callable, so it is not in general safe to store
+/// a function_ref.
+template<typename Fn> class function_ref;
+
+template<typename Ret, typename ...Params>
+class function_ref<Ret(Params...)> {
+  Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
+  intptr_t callable;
+
+  template<typename Callable>
+  static Ret callback_fn(intptr_t callable, Params ...params) {
+    return (*reinterpret_cast<Callable*>(callable))(
+        std::forward<Params>(params)...);
+  }
+
+public:
+  function_ref() = default;
+  function_ref(std::nullptr_t) {}
+
+  template <typename Callable>
+  function_ref(
+      Callable &&callable,
+      // This is not the copy-constructor.
+      std::enable_if_t<!std::is_same<remove_cvref_t<Callable>,
+                                     function_ref>::value> * = nullptr,
+      // Functor must be callable and return a suitable type.
+      std::enable_if_t<std::is_void<Ret>::value ||
+                       std::is_convertible<decltype(std::declval<Callable>()(
+                                               std::declval<Params>()...)),
+                                           Ret>::value> * = nullptr)
+      : callback(callback_fn<std::remove_reference_t<Callable>>),
+        callable(reinterpret_cast<intptr_t>(&callable)) {}
+
+  Ret operator()(Params ...params) const {
+    return callback(callable, std::forward<Params>(params)...);
+  }
+
+  explicit operator bool() const { return callback; }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_ADT_STLFUNCTIONALEXTRAS_H
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/SmallVector.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/SmallVector.h
deleted file mode 100644
index b8a11030f..000000000
--- a/symbolic-demangle/vendor/swift/include/llvm/ADT/SmallVector.h
+++ /dev/null
@@ -1,1273 +0,0 @@
-//===- llvm/ADT/SmallVector.h - 'Normally small' vectors --------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the SmallVector class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_SMALLVECTOR_H
-#define LLVM_ADT_SMALLVECTOR_H
-
-#include "llvm/ADT/iterator_range.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/MemAlloc.h"
-#include "llvm/Support/type_traits.h"
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <functional>
-#include <initializer_list>
-#include <iterator>
-#include <limits>
-#include <memory>
-#include <new>
-#include <type_traits>
-#include <utility>
-
-namespace llvm {
-
-/// This is all the stuff common to all SmallVectors.
-///
-/// The template parameter specifies the type which should be used to hold the
-/// Size and Capacity of the SmallVector, so it can be adjusted.
-/// Using 32 bit size is desirable to shrink the size of the SmallVector.
-/// Using 64 bit size is desirable for cases like SmallVector<char>, where a
-/// 32 bit size would limit the vector to ~4GB. SmallVectors are used for
-/// buffering bitcode output - which can exceed 4GB.
-template <class Size_T> class SmallVectorBase {
-protected:
-  void *BeginX;
-  Size_T Size = 0, Capacity;
-
-  /// The maximum value of the Size_T used.
-  static constexpr size_t SizeTypeMax() {
-    return std::numeric_limits<Size_T>::max();
-  }
-
-  SmallVectorBase() = delete;
-  SmallVectorBase(void *FirstEl, size_t TotalCapacity)
-      : BeginX(FirstEl), Capacity(TotalCapacity) {}
-
-  /// This is a helper for \a grow() that's out of line to reduce code
-  /// duplication.  This function will report a fatal error if it can't grow at
-  /// least to \p MinSize.
-  void *mallocForGrow(size_t MinSize, size_t TSize, size_t &NewCapacity);
-
-  /// This is an implementation of the grow() method which only works
-  /// on POD-like data types and is out of line to reduce code duplication.
-  /// This function will report a fatal error if it cannot increase capacity.
-  void grow_pod(void *FirstEl, size_t MinSize, size_t TSize);
-
-public:
-  size_t size() const { return Size; }
-  size_t capacity() const { return Capacity; }
-
-  LLVM_NODISCARD bool empty() const { return !Size; }
-
-  /// Set the array size to \p N, which the current array must have enough
-  /// capacity for.
-  ///
-  /// This does not construct or destroy any elements in the vector.
-  ///
-  /// Clients can use this in conjunction with capacity() to write past the end
-  /// of the buffer when they know that more elements are available, and only
-  /// update the size later. This avoids the cost of value initializing elements
-  /// which will only be overwritten.
-  void set_size(size_t N) {
-    assert(N <= capacity());
-    Size = N;
-  }
-};
-
-template <class T>
-using SmallVectorSizeType =
-    typename std::conditional<sizeof(T) < 4 && sizeof(void *) >= 8, uint64_t,
-                              uint32_t>::type;
-
-/// Figure out the offset of the first element.
-template <class T, typename = void> struct SmallVectorAlignmentAndSize {
-  alignas(SmallVectorBase<SmallVectorSizeType<T>>) char Base[sizeof(
-      SmallVectorBase<SmallVectorSizeType<T>>)];
-  alignas(T) char FirstEl[sizeof(T)];
-};
-
-/// This is the part of SmallVectorTemplateBase which does not depend on whether
-/// the type T is a POD. The extra dummy template argument is used by ArrayRef
-/// to avoid unnecessarily requiring T to be complete.
-template <typename T, typename = void>
-class SmallVectorTemplateCommon
-    : public SmallVectorBase<SmallVectorSizeType<T>> {
-  using Base = SmallVectorBase<SmallVectorSizeType<T>>;
-
-  /// Find the address of the first element.  For this pointer math to be valid
-  /// with small-size of 0 for T with lots of alignment, it's important that
-  /// SmallVectorStorage is properly-aligned even for small-size of 0.
-  void *getFirstEl() const {
-    return const_cast<void *>(reinterpret_cast<const void *>(
-        reinterpret_cast<const char *>(this) +
-        offsetof(SmallVectorAlignmentAndSize<T>, FirstEl)));
-  }
-  // Space after 'FirstEl' is clobbered, do not add any instance vars after it.
-
-protected:
-  SmallVectorTemplateCommon(size_t Size) : Base(getFirstEl(), Size) {}
-
-  void grow_pod(size_t MinSize, size_t TSize) {
-    Base::grow_pod(getFirstEl(), MinSize, TSize);
-  }
-
-  /// Return true if this is a smallvector which has not had dynamic
-  /// memory allocated for it.
-  bool isSmall() const { return this->BeginX == getFirstEl(); }
-
-  /// Put this vector in a state of being small.
-  void resetToSmall() {
-    this->BeginX = getFirstEl();
-    this->Size = this->Capacity = 0; // FIXME: Setting Capacity to 0 is suspect.
-  }
-
-  /// Return true if V is an internal reference to the given range.
-  bool isReferenceToRange(const void *V, const void *First, const void *Last) const {
-    // Use std::less to avoid UB.
-    std::less<> LessThan;
-    return !LessThan(V, First) && LessThan(V, Last);
-  }
-
-  /// Return true if V is an internal reference to this vector.
-  bool isReferenceToStorage(const void *V) const {
-    return isReferenceToRange(V, this->begin(), this->end());
-  }
-
-  /// Return true if First and Last form a valid (possibly empty) range in this
-  /// vector's storage.
-  bool isRangeInStorage(const void *First, const void *Last) const {
-    // Use std::less to avoid UB.
-    std::less<> LessThan;
-    return !LessThan(First, this->begin()) && !LessThan(Last, First) &&
-           !LessThan(this->end(), Last);
-  }
-
-  /// Return true unless Elt will be invalidated by resizing the vector to
-  /// NewSize.
-  bool isSafeToReferenceAfterResize(const void *Elt, size_t NewSize) {
-    // Past the end.
-    if (LLVM_LIKELY(!isReferenceToStorage(Elt)))
-      return true;
-
-    // Return false if Elt will be destroyed by shrinking.
-    if (NewSize <= this->size())
-      return Elt < this->begin() + NewSize;
-
-    // Return false if we need to grow.
-    return NewSize <= this->capacity();
-  }
-
-  /// Check whether Elt will be invalidated by resizing the vector to NewSize.
-  void assertSafeToReferenceAfterResize(const void *Elt, size_t NewSize) {
-    assert(isSafeToReferenceAfterResize(Elt, NewSize) &&
-           "Attempting to reference an element of the vector in an operation "
-           "that invalidates it");
-  }
-
-  /// Check whether Elt will be invalidated by increasing the size of the
-  /// vector by N.
-  void assertSafeToAdd(const void *Elt, size_t N = 1) {
-    this->assertSafeToReferenceAfterResize(Elt, this->size() + N);
-  }
-
-  /// Check whether any part of the range will be invalidated by clearing.
-  void assertSafeToReferenceAfterClear(const T *From, const T *To) {
-    if (From == To)
-      return;
-    this->assertSafeToReferenceAfterResize(From, 0);
-    this->assertSafeToReferenceAfterResize(To - 1, 0);
-  }
-  template <
-      class ItTy,
-      std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
-                       bool> = false>
-  void assertSafeToReferenceAfterClear(ItTy, ItTy) {}
-
-  /// Check whether any part of the range will be invalidated by growing.
-  void assertSafeToAddRange(const T *From, const T *To) {
-    if (From == To)
-      return;
-    this->assertSafeToAdd(From, To - From);
-    this->assertSafeToAdd(To - 1, To - From);
-  }
-  template <
-      class ItTy,
-      std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
-                       bool> = false>
-  void assertSafeToAddRange(ItTy, ItTy) {}
-
-  /// Reserve enough space to add one element, and return the updated element
-  /// pointer in case it was a reference to the storage.
-  template <class U>
-  static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
-                                                   size_t N) {
-    size_t NewSize = This->size() + N;
-    if (LLVM_LIKELY(NewSize <= This->capacity()))
-      return &Elt;
-
-    bool ReferencesStorage = false;
-    int64_t Index = -1;
-    if (!U::TakesParamByValue) {
-      if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
-        ReferencesStorage = true;
-        Index = &Elt - This->begin();
-      }
-    }
-    This->grow(NewSize);
-    return ReferencesStorage ? This->begin() + Index : &Elt;
-  }
-
-public:
-  using size_type = size_t;
-  using difference_type = ptrdiff_t;
-  using value_type = T;
-  using iterator = T *;
-  using const_iterator = const T *;
-
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  using reverse_iterator = std::reverse_iterator<iterator>;
-
-  using reference = T &;
-  using const_reference = const T &;
-  using pointer = T *;
-  using const_pointer = const T *;
-
-  using Base::capacity;
-  using Base::empty;
-  using Base::size;
-
-  // forward iterator creation methods.
-  iterator begin() { return (iterator)this->BeginX; }
-  const_iterator begin() const { return (const_iterator)this->BeginX; }
-  iterator end() { return begin() + size(); }
-  const_iterator end() const { return begin() + size(); }
-
-  // reverse iterator creation methods.
-  reverse_iterator rbegin()            { return reverse_iterator(end()); }
-  const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
-  reverse_iterator rend()              { return reverse_iterator(begin()); }
-  const_reverse_iterator rend() const { return const_reverse_iterator(begin());}
-
-  size_type size_in_bytes() const { return size() * sizeof(T); }
-  size_type max_size() const {
-    return std::min(this->SizeTypeMax(), size_type(-1) / sizeof(T));
-  }
-
-  size_t capacity_in_bytes() const { return capacity() * sizeof(T); }
-
-  /// Return a pointer to the vector's buffer, even if empty().
-  pointer data() { return pointer(begin()); }
-  /// Return a pointer to the vector's buffer, even if empty().
-  const_pointer data() const { return const_pointer(begin()); }
-
-  reference operator[](size_type idx) {
-    assert(idx < size());
-    return begin()[idx];
-  }
-  const_reference operator[](size_type idx) const {
-    assert(idx < size());
-    return begin()[idx];
-  }
-
-  reference front() {
-    assert(!empty());
-    return begin()[0];
-  }
-  const_reference front() const {
-    assert(!empty());
-    return begin()[0];
-  }
-
-  reference back() {
-    assert(!empty());
-    return end()[-1];
-  }
-  const_reference back() const {
-    assert(!empty());
-    return end()[-1];
-  }
-};
-
-/// SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put
-/// method implementations that are designed to work with non-trivial T's.
-///
-/// We approximate is_trivially_copyable with trivial move/copy construction and
-/// trivial destruction. While the standard doesn't specify that you're allowed
-/// copy these types with memcpy, there is no way for the type to observe this.
-/// This catches the important case of std::pair<POD, POD>, which is not
-/// trivially assignable.
-template <typename T, bool = (is_trivially_copy_constructible<T>::value) &&
-                             (is_trivially_move_constructible<T>::value) &&
-                             std::is_trivially_destructible<T>::value>
-class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
-  friend class SmallVectorTemplateCommon<T>;
-
-protected:
-  static constexpr bool TakesParamByValue = false;
-  using ValueParamT = const T &;
-
-  SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
-
-  static void destroy_range(T *S, T *E) {
-    while (S != E) {
-      --E;
-      E->~T();
-    }
-  }
-
-  /// Move the range [I, E) into the uninitialized memory starting with "Dest",
-  /// constructing elements as needed.
-  template<typename It1, typename It2>
-  static void uninitialized_move(It1 I, It1 E, It2 Dest) {
-    std::uninitialized_copy(std::make_move_iterator(I),
-                            std::make_move_iterator(E), Dest);
-  }
-
-  /// Copy the range [I, E) onto the uninitialized memory starting with "Dest",
-  /// constructing elements as needed.
-  template<typename It1, typename It2>
-  static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
-    std::uninitialized_copy(I, E, Dest);
-  }
-
-  /// Grow the allocated memory (without initializing new elements), doubling
-  /// the size of the allocated memory. Guarantees space for at least one more
-  /// element, or MinSize more elements if specified.
-  void grow(size_t MinSize = 0);
-
-  /// Create a new allocation big enough for \p MinSize and pass back its size
-  /// in \p NewCapacity. This is the first section of \a grow().
-  T *mallocForGrow(size_t MinSize, size_t &NewCapacity) {
-    return static_cast<T *>(
-        SmallVectorBase<SmallVectorSizeType<T>>::mallocForGrow(
-            MinSize, sizeof(T), NewCapacity));
-  }
-
-  /// Move existing elements over to the new allocation \p NewElts, the middle
-  /// section of \a grow().
-  void moveElementsForGrow(T *NewElts);
-
-  /// Transfer ownership of the allocation, finishing up \a grow().
-  void takeAllocationForGrow(T *NewElts, size_t NewCapacity);
-
-  /// Reserve enough space to add one element, and return the updated element
-  /// pointer in case it was a reference to the storage.
-  const T *reserveForParamAndGetAddress(const T &Elt, size_t N = 1) {
-    return this->reserveForParamAndGetAddressImpl(this, Elt, N);
-  }
-
-  /// Reserve enough space to add one element, and return the updated element
-  /// pointer in case it was a reference to the storage.
-  T *reserveForParamAndGetAddress(T &Elt, size_t N = 1) {
-    return const_cast<T *>(
-        this->reserveForParamAndGetAddressImpl(this, Elt, N));
-  }
-
-  static T &&forward_value_param(T &&V) { return std::move(V); }
-  static const T &forward_value_param(const T &V) { return V; }
-
-  void growAndAssign(size_t NumElts, const T &Elt) {
-    // Grow manually in case Elt is an internal reference.
-    size_t NewCapacity;
-    T *NewElts = mallocForGrow(NumElts, NewCapacity);
-    std::uninitialized_fill_n(NewElts, NumElts, Elt);
-    this->destroy_range(this->begin(), this->end());
-    takeAllocationForGrow(NewElts, NewCapacity);
-    this->set_size(NumElts);
-  }
-
-  template <typename... ArgTypes> T &growAndEmplaceBack(ArgTypes &&... Args) {
-    // Grow manually in case one of Args is an internal reference.
-    size_t NewCapacity;
-    T *NewElts = mallocForGrow(0, NewCapacity);
-    ::new ((void *)(NewElts + this->size())) T(std::forward<ArgTypes>(Args)...);
-    moveElementsForGrow(NewElts);
-    takeAllocationForGrow(NewElts, NewCapacity);
-    this->set_size(this->size() + 1);
-    return this->back();
-  }
-
-public:
-  void push_back(const T &Elt) {
-    const T *EltPtr = reserveForParamAndGetAddress(Elt);
-    ::new ((void *)this->end()) T(*EltPtr);
-    this->set_size(this->size() + 1);
-  }
-
-  void push_back(T &&Elt) {
-    T *EltPtr = reserveForParamAndGetAddress(Elt);
-    ::new ((void *)this->end()) T(::std::move(*EltPtr));
-    this->set_size(this->size() + 1);
-  }
-
-  void pop_back() {
-    this->set_size(this->size() - 1);
-    this->end()->~T();
-  }
-};
-
-// Define this out-of-line to dissuade the C++ compiler from inlining it.
-template <typename T, bool TriviallyCopyable>
-void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
-  size_t NewCapacity;
-  T *NewElts = mallocForGrow(MinSize, NewCapacity);
-  moveElementsForGrow(NewElts);
-  takeAllocationForGrow(NewElts, NewCapacity);
-}
-
-// Define this out-of-line to dissuade the C++ compiler from inlining it.
-template <typename T, bool TriviallyCopyable>
-void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
-    T *NewElts) {
-  // Move the elements over.
-  this->uninitialized_move(this->begin(), this->end(), NewElts);
-
-  // Destroy the original elements.
-  destroy_range(this->begin(), this->end());
-}
-
-// Define this out-of-line to dissuade the C++ compiler from inlining it.
-template <typename T, bool TriviallyCopyable>
-void SmallVectorTemplateBase<T, TriviallyCopyable>::takeAllocationForGrow(
-    T *NewElts, size_t NewCapacity) {
-  // If this wasn't grown from the inline copy, deallocate the old space.
-  if (!this->isSmall())
-    free(this->begin());
-
-  this->BeginX = NewElts;
-  this->Capacity = NewCapacity;
-}
-
-/// SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put
-/// method implementations that are designed to work with trivially copyable
-/// T's. This allows using memcpy in place of copy/move construction and
-/// skipping destruction.
-template <typename T>
-class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
-  friend class SmallVectorTemplateCommon<T>;
-
-protected:
-  /// True if it's cheap enough to take parameters by value. Doing so avoids
-  /// overhead related to mitigations for reference invalidation.
-  static constexpr bool TakesParamByValue = sizeof(T) <= 2 * sizeof(void *);
-
-  /// Either const T& or T, depending on whether it's cheap enough to take
-  /// parameters by value.
-  using ValueParamT =
-      typename std::conditional<TakesParamByValue, T, const T &>::type;
-
-  SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
-
-  // No need to do a destroy loop for POD's.
-  static void destroy_range(T *, T *) {}
-
-  /// Move the range [I, E) onto the uninitialized memory
-  /// starting with "Dest", constructing elements into it as needed.
-  template<typename It1, typename It2>
-  static void uninitialized_move(It1 I, It1 E, It2 Dest) {
-    // Just do a copy.
-    uninitialized_copy(I, E, Dest);
-  }
-
-  /// Copy the range [I, E) onto the uninitialized memory
-  /// starting with "Dest", constructing elements into it as needed.
-  template<typename It1, typename It2>
-  static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
-    // Arbitrary iterator types; just use the basic implementation.
-    std::uninitialized_copy(I, E, Dest);
-  }
-
-  /// Copy the range [I, E) onto the uninitialized memory
-  /// starting with "Dest", constructing elements into it as needed.
-  template <typename T1, typename T2>
-  static void uninitialized_copy(
-      T1 *I, T1 *E, T2 *Dest,
-      std::enable_if_t<std::is_same<typename std::remove_const<T1>::type,
-                                    T2>::value> * = nullptr) {
-    // Use memcpy for PODs iterated by pointers (which includes SmallVector
-    // iterators): std::uninitialized_copy optimizes to memmove, but we can
-    // use memcpy here. Note that I and E are iterators and thus might be
-    // invalid for memcpy if they are equal.
-    if (I != E)
-      memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
-  }
-
-  /// Double the size of the allocated memory, guaranteeing space for at
-  /// least one more element or MinSize if specified.
-  void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
-
-  /// Reserve enough space to add one element, and return the updated element
-  /// pointer in case it was a reference to the storage.
-  const T *reserveForParamAndGetAddress(const T &Elt, size_t N = 1) {
-    return this->reserveForParamAndGetAddressImpl(this, Elt, N);
-  }
-
-  /// Reserve enough space to add one element, and return the updated element
-  /// pointer in case it was a reference to the storage.
-  T *reserveForParamAndGetAddress(T &Elt, size_t N = 1) {
-    return const_cast<T *>(
-        this->reserveForParamAndGetAddressImpl(this, Elt, N));
-  }
-
-  /// Copy \p V or return a reference, depending on \a ValueParamT.
-  static ValueParamT forward_value_param(ValueParamT V) { return V; }
-
-  void growAndAssign(size_t NumElts, T Elt) {
-    // Elt has been copied in case it's an internal reference, side-stepping
-    // reference invalidation problems without losing the realloc optimization.
-    this->set_size(0);
-    this->grow(NumElts);
-    std::uninitialized_fill_n(this->begin(), NumElts, Elt);
-    this->set_size(NumElts);
-  }
-
-  template <typename... ArgTypes> T &growAndEmplaceBack(ArgTypes &&... Args) {
-    // Use push_back with a copy in case Args has an internal reference,
-    // side-stepping reference invalidation problems without losing the realloc
-    // optimization.
-    push_back(T(std::forward<ArgTypes>(Args)...));
-    return this->back();
-  }
-
-public:
-  void push_back(ValueParamT Elt) {
-    const T *EltPtr = reserveForParamAndGetAddress(Elt);
-    memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
-    this->set_size(this->size() + 1);
-  }
-
-  void pop_back() { this->set_size(this->size() - 1); }
-};
-
-/// This class consists of common code factored out of the SmallVector class to
-/// reduce code duplication based on the SmallVector 'N' template parameter.
-template <typename T>
-class SmallVectorImpl : public SmallVectorTemplateBase<T> {
-  using SuperClass = SmallVectorTemplateBase<T>;
-
-public:
-  using iterator = typename SuperClass::iterator;
-  using const_iterator = typename SuperClass::const_iterator;
-  using reference = typename SuperClass::reference;
-  using size_type = typename SuperClass::size_type;
-
-protected:
-  using SmallVectorTemplateBase<T>::TakesParamByValue;
-  using ValueParamT = typename SuperClass::ValueParamT;
-
-  // Default ctor - Initialize to empty.
-  explicit SmallVectorImpl(unsigned N)
-      : SmallVectorTemplateBase<T>(N) {}
-
-public:
-  SmallVectorImpl(const SmallVectorImpl &) = delete;
-
-  ~SmallVectorImpl() {
-    // Subclass has already destructed this vector's elements.
-    // If this wasn't grown from the inline copy, deallocate the old space.
-    if (!this->isSmall())
-      free(this->begin());
-  }
-
-  void clear() {
-    this->destroy_range(this->begin(), this->end());
-    this->Size = 0;
-  }
-
-private:
-  template <bool ForOverwrite> void resizeImpl(size_type N) {
-    if (N < this->size()) {
-      this->pop_back_n(this->size() - N);
-    } else if (N > this->size()) {
-      this->reserve(N);
-      for (auto I = this->end(), E = this->begin() + N; I != E; ++I)
-        if (ForOverwrite)
-          new (&*I) T;
-        else
-          new (&*I) T();
-      this->set_size(N);
-    }
-  }
-
-public:
-  void resize(size_type N) { resizeImpl<false>(N); }
-
-  /// Like resize, but \ref T is POD, the new values won't be initialized.
-  void resize_for_overwrite(size_type N) { resizeImpl<true>(N); }
-
-  void resize(size_type N, ValueParamT NV) {
-    if (N == this->size())
-      return;
-
-    if (N < this->size()) {
-      this->pop_back_n(this->size() - N);
-      return;
-    }
-
-    // N > this->size(). Defer to append.
-    this->append(N - this->size(), NV);
-  }
-
-  void reserve(size_type N) {
-    if (this->capacity() < N)
-      this->grow(N);
-  }
-
-  void pop_back_n(size_type NumItems) {
-    assert(this->size() >= NumItems);
-    this->destroy_range(this->end() - NumItems, this->end());
-    this->set_size(this->size() - NumItems);
-  }
-
-  LLVM_NODISCARD T pop_back_val() {
-    T Result = ::std::move(this->back());
-    this->pop_back();
-    return Result;
-  }
-
-  void swap(SmallVectorImpl &RHS);
-
-  /// Add the specified range to the end of the SmallVector.
-  template <typename in_iter,
-            typename = std::enable_if_t<std::is_convertible<
-                typename std::iterator_traits<in_iter>::iterator_category,
-                std::input_iterator_tag>::value>>
-  void append(in_iter in_start, in_iter in_end) {
-    this->assertSafeToAddRange(in_start, in_end);
-    size_type NumInputs = std::distance(in_start, in_end);
-    this->reserve(this->size() + NumInputs);
-    this->uninitialized_copy(in_start, in_end, this->end());
-    this->set_size(this->size() + NumInputs);
-  }
-
-  /// Append \p NumInputs copies of \p Elt to the end.
-  void append(size_type NumInputs, ValueParamT Elt) {
-    const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumInputs);
-    std::uninitialized_fill_n(this->end(), NumInputs, *EltPtr);
-    this->set_size(this->size() + NumInputs);
-  }
-
-  void append(std::initializer_list<T> IL) {
-    append(IL.begin(), IL.end());
-  }
-
-  void append(const SmallVectorImpl &RHS) { append(RHS.begin(), RHS.end()); }
-
-  void assign(size_type NumElts, ValueParamT Elt) {
-    // Note that Elt could be an internal reference.
-    if (NumElts > this->capacity()) {
-      this->growAndAssign(NumElts, Elt);
-      return;
-    }
-
-    // Assign over existing elements.
-    std::fill_n(this->begin(), std::min(NumElts, this->size()), Elt);
-    if (NumElts > this->size())
-      std::uninitialized_fill_n(this->end(), NumElts - this->size(), Elt);
-    else if (NumElts < this->size())
-      this->destroy_range(this->begin() + NumElts, this->end());
-    this->set_size(NumElts);
-  }
-
-  // FIXME: Consider assigning over existing elements, rather than clearing &
-  // re-initializing them - for all assign(...) variants.
-
-  template <typename in_iter,
-            typename = std::enable_if_t<std::is_convertible<
-                typename std::iterator_traits<in_iter>::iterator_category,
-                std::input_iterator_tag>::value>>
-  void assign(in_iter in_start, in_iter in_end) {
-    this->assertSafeToReferenceAfterClear(in_start, in_end);
-    clear();
-    append(in_start, in_end);
-  }
-
-  void assign(std::initializer_list<T> IL) {
-    clear();
-    append(IL);
-  }
-
-  void assign(const SmallVectorImpl &RHS) { assign(RHS.begin(), RHS.end()); }
-
-  iterator erase(const_iterator CI) {
-    // Just cast away constness because this is a non-const member function.
-    iterator I = const_cast<iterator>(CI);
-
-    assert(this->isReferenceToStorage(CI) && "Iterator to erase is out of bounds.");
-
-    iterator N = I;
-    // Shift all elts down one.
-    std::move(I+1, this->end(), I);
-    // Drop the last elt.
-    this->pop_back();
-    return(N);
-  }
-
-  iterator erase(const_iterator CS, const_iterator CE) {
-    // Just cast away constness because this is a non-const member function.
-    iterator S = const_cast<iterator>(CS);
-    iterator E = const_cast<iterator>(CE);
-
-    assert(this->isRangeInStorage(S, E) && "Range to erase is out of bounds.");
-
-    iterator N = S;
-    // Shift all elts down.
-    iterator I = std::move(E, this->end(), S);
-    // Drop the last elts.
-    this->destroy_range(I, this->end());
-    this->set_size(I - this->begin());
-    return(N);
-  }
-
-private:
-  template <class ArgType> iterator insert_one_impl(iterator I, ArgType &&Elt) {
-    // Callers ensure that ArgType is derived from T.
-    static_assert(
-        std::is_same<std::remove_const_t<std::remove_reference_t<ArgType>>,
-                     T>::value,
-        "ArgType must be derived from T!");
-
-    if (I == this->end()) {  // Important special case for empty vector.
-      this->push_back(::std::forward<ArgType>(Elt));
-      return this->end()-1;
-    }
-
-    assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
-
-    // Grow if necessary.
-    size_t Index = I - this->begin();
-    std::remove_reference_t<ArgType> *EltPtr =
-        this->reserveForParamAndGetAddress(Elt);
-    I = this->begin() + Index;
-
-    ::new ((void*) this->end()) T(::std::move(this->back()));
-    // Push everything else over.
-    std::move_backward(I, this->end()-1, this->end());
-    this->set_size(this->size() + 1);
-
-    // If we just moved the element we're inserting, be sure to update
-    // the reference (never happens if TakesParamByValue).
-    static_assert(!TakesParamByValue || std::is_same<ArgType, T>::value,
-                  "ArgType must be 'T' when taking by value!");
-    if (!TakesParamByValue && this->isReferenceToRange(EltPtr, I, this->end()))
-      ++EltPtr;
-
-    *I = ::std::forward<ArgType>(*EltPtr);
-    return I;
-  }
-
-public:
-  iterator insert(iterator I, T &&Elt) {
-    return insert_one_impl(I, this->forward_value_param(std::move(Elt)));
-  }
-
-  iterator insert(iterator I, const T &Elt) {
-    return insert_one_impl(I, this->forward_value_param(Elt));
-  }
-
-  iterator insert(iterator I, size_type NumToInsert, ValueParamT Elt) {
-    // Convert iterator to elt# to avoid invalidating iterator when we reserve()
-    size_t InsertElt = I - this->begin();
-
-    if (I == this->end()) {  // Important special case for empty vector.
-      append(NumToInsert, Elt);
-      return this->begin()+InsertElt;
-    }
-
-    assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
-
-    // Ensure there is enough space, and get the (maybe updated) address of
-    // Elt.
-    const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumToInsert);
-
-    // Uninvalidate the iterator.
-    I = this->begin()+InsertElt;
-
-    // If there are more elements between the insertion point and the end of the
-    // range than there are being inserted, we can use a simple approach to
-    // insertion.  Since we already reserved space, we know that this won't
-    // reallocate the vector.
-    if (size_t(this->end()-I) >= NumToInsert) {
-      T *OldEnd = this->end();
-      append(std::move_iterator<iterator>(this->end() - NumToInsert),
-             std::move_iterator<iterator>(this->end()));
-
-      // Copy the existing elements that get replaced.
-      std::move_backward(I, OldEnd-NumToInsert, OldEnd);
-
-      // If we just moved the element we're inserting, be sure to update
-      // the reference (never happens if TakesParamByValue).
-      if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
-        EltPtr += NumToInsert;
-
-      std::fill_n(I, NumToInsert, *EltPtr);
-      return I;
-    }
-
-    // Otherwise, we're inserting more elements than exist already, and we're
-    // not inserting at the end.
-
-    // Move over the elements that we're about to overwrite.
-    T *OldEnd = this->end();
-    this->set_size(this->size() + NumToInsert);
-    size_t NumOverwritten = OldEnd-I;
-    this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
-
-    // If we just moved the element we're inserting, be sure to update
-    // the reference (never happens if TakesParamByValue).
-    if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
-      EltPtr += NumToInsert;
-
-    // Replace the overwritten part.
-    std::fill_n(I, NumOverwritten, *EltPtr);
-
-    // Insert the non-overwritten middle part.
-    std::uninitialized_fill_n(OldEnd, NumToInsert - NumOverwritten, *EltPtr);
-    return I;
-  }
-
-  template <typename ItTy,
-            typename = std::enable_if_t<std::is_convertible<
-                typename std::iterator_traits<ItTy>::iterator_category,
-                std::input_iterator_tag>::value>>
-  iterator insert(iterator I, ItTy From, ItTy To) {
-    // Convert iterator to elt# to avoid invalidating iterator when we reserve()
-    size_t InsertElt = I - this->begin();
-
-    if (I == this->end()) {  // Important special case for empty vector.
-      append(From, To);
-      return this->begin()+InsertElt;
-    }
-
-    assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
-
-    // Check that the reserve that follows doesn't invalidate the iterators.
-    this->assertSafeToAddRange(From, To);
-
-    size_t NumToInsert = std::distance(From, To);
-
-    // Ensure there is enough space.
-    reserve(this->size() + NumToInsert);
-
-    // Uninvalidate the iterator.
-    I = this->begin()+InsertElt;
-
-    // If there are more elements between the insertion point and the end of the
-    // range than there are being inserted, we can use a simple approach to
-    // insertion.  Since we already reserved space, we know that this won't
-    // reallocate the vector.
-    if (size_t(this->end()-I) >= NumToInsert) {
-      T *OldEnd = this->end();
-      append(std::move_iterator<iterator>(this->end() - NumToInsert),
-             std::move_iterator<iterator>(this->end()));
-
-      // Copy the existing elements that get replaced.
-      std::move_backward(I, OldEnd-NumToInsert, OldEnd);
-
-      std::copy(From, To, I);
-      return I;
-    }
-
-    // Otherwise, we're inserting more elements than exist already, and we're
-    // not inserting at the end.
-
-    // Move over the elements that we're about to overwrite.
-    T *OldEnd = this->end();
-    this->set_size(this->size() + NumToInsert);
-    size_t NumOverwritten = OldEnd-I;
-    this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
-
-    // Replace the overwritten part.
-    for (T *J = I; NumOverwritten > 0; --NumOverwritten) {
-      *J = *From;
-      ++J; ++From;
-    }
-
-    // Insert the non-overwritten middle part.
-    this->uninitialized_copy(From, To, OldEnd);
-    return I;
-  }
-
-  void insert(iterator I, std::initializer_list<T> IL) {
-    insert(I, IL.begin(), IL.end());
-  }
-
-  template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
-    if (LLVM_UNLIKELY(this->size() >= this->capacity()))
-      return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);
-
-    ::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
-    this->set_size(this->size() + 1);
-    return this->back();
-  }
-
-  SmallVectorImpl &operator=(const SmallVectorImpl &RHS);
-
-  SmallVectorImpl &operator=(SmallVectorImpl &&RHS);
-
-  bool operator==(const SmallVectorImpl &RHS) const {
-    if (this->size() != RHS.size()) return false;
-    return std::equal(this->begin(), this->end(), RHS.begin());
-  }
-  bool operator!=(const SmallVectorImpl &RHS) const {
-    return !(*this == RHS);
-  }
-
-  bool operator<(const SmallVectorImpl &RHS) const {
-    return std::lexicographical_compare(this->begin(), this->end(),
-                                        RHS.begin(), RHS.end());
-  }
-};
-
-template <typename T>
-void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
-  if (this == &RHS) return;
-
-  // We can only avoid copying elements if neither vector is small.
-  if (!this->isSmall() && !RHS.isSmall()) {
-    std::swap(this->BeginX, RHS.BeginX);
-    std::swap(this->Size, RHS.Size);
-    std::swap(this->Capacity, RHS.Capacity);
-    return;
-  }
-  this->reserve(RHS.size());
-  RHS.reserve(this->size());
-
-  // Swap the shared elements.
-  size_t NumShared = this->size();
-  if (NumShared > RHS.size()) NumShared = RHS.size();
-  for (size_type i = 0; i != NumShared; ++i)
-    std::swap((*this)[i], RHS[i]);
-
-  // Copy over the extra elts.
-  if (this->size() > RHS.size()) {
-    size_t EltDiff = this->size() - RHS.size();
-    this->uninitialized_copy(this->begin()+NumShared, this->end(), RHS.end());
-    RHS.set_size(RHS.size() + EltDiff);
-    this->destroy_range(this->begin()+NumShared, this->end());
-    this->set_size(NumShared);
-  } else if (RHS.size() > this->size()) {
-    size_t EltDiff = RHS.size() - this->size();
-    this->uninitialized_copy(RHS.begin()+NumShared, RHS.end(), this->end());
-    this->set_size(this->size() + EltDiff);
-    this->destroy_range(RHS.begin()+NumShared, RHS.end());
-    RHS.set_size(NumShared);
-  }
-}
-
-template <typename T>
-SmallVectorImpl<T> &SmallVectorImpl<T>::
-  operator=(const SmallVectorImpl<T> &RHS) {
-  // Avoid self-assignment.
-  if (this == &RHS) return *this;
-
-  // If we already have sufficient space, assign the common elements, then
-  // destroy any excess.
-  size_t RHSSize = RHS.size();
-  size_t CurSize = this->size();
-  if (CurSize >= RHSSize) {
-    // Assign common elements.
-    iterator NewEnd;
-    if (RHSSize)
-      NewEnd = std::copy(RHS.begin(), RHS.begin()+RHSSize, this->begin());
-    else
-      NewEnd = this->begin();
-
-    // Destroy excess elements.
-    this->destroy_range(NewEnd, this->end());
-
-    // Trim.
-    this->set_size(RHSSize);
-    return *this;
-  }
-
-  // If we have to grow to have enough elements, destroy the current elements.
-  // This allows us to avoid copying them during the grow.
-  // FIXME: don't do this if they're efficiently moveable.
-  if (this->capacity() < RHSSize) {
-    // Destroy current elements.
-    this->clear();
-    CurSize = 0;
-    this->grow(RHSSize);
-  } else if (CurSize) {
-    // Otherwise, use assignment for the already-constructed elements.
-    std::copy(RHS.begin(), RHS.begin()+CurSize, this->begin());
-  }
-
-  // Copy construct the new elements in place.
-  this->uninitialized_copy(RHS.begin()+CurSize, RHS.end(),
-                           this->begin()+CurSize);
-
-  // Set end.
-  this->set_size(RHSSize);
-  return *this;
-}
-
-template <typename T>
-SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
-  // Avoid self-assignment.
-  if (this == &RHS) return *this;
-
-  // If the RHS isn't small, clear this vector and then steal its buffer.
-  if (!RHS.isSmall()) {
-    this->destroy_range(this->begin(), this->end());
-    if (!this->isSmall()) free(this->begin());
-    this->BeginX = RHS.BeginX;
-    this->Size = RHS.Size;
-    this->Capacity = RHS.Capacity;
-    RHS.resetToSmall();
-    return *this;
-  }
-
-  // If we already have sufficient space, assign the common elements, then
-  // destroy any excess.
-  size_t RHSSize = RHS.size();
-  size_t CurSize = this->size();
-  if (CurSize >= RHSSize) {
-    // Assign common elements.
-    iterator NewEnd = this->begin();
-    if (RHSSize)
-      NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);
-
-    // Destroy excess elements and trim the bounds.
-    this->destroy_range(NewEnd, this->end());
-    this->set_size(RHSSize);
-
-    // Clear the RHS.
-    RHS.clear();
-
-    return *this;
-  }
-
-  // If we have to grow to have enough elements, destroy the current elements.
-  // This allows us to avoid copying them during the grow.
-  // FIXME: this may not actually make any sense if we can efficiently move
-  // elements.
-  if (this->capacity() < RHSSize) {
-    // Destroy current elements.
-    this->clear();
-    CurSize = 0;
-    this->grow(RHSSize);
-  } else if (CurSize) {
-    // Otherwise, use assignment for the already-constructed elements.
-    std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
-  }
-
-  // Move-construct the new elements in place.
-  this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
-                           this->begin()+CurSize);
-
-  // Set end.
-  this->set_size(RHSSize);
-
-  RHS.clear();
-  return *this;
-}
-
-/// Storage for the SmallVector elements.  This is specialized for the N=0 case
-/// to avoid allocating unnecessary storage.
-template <typename T, unsigned N>
-struct SmallVectorStorage {
-  alignas(T) char InlineElts[N * sizeof(T)];
-};
-
-/// We need the storage to be properly aligned even for small-size of 0 so that
-/// the pointer math in \a SmallVectorTemplateCommon::getFirstEl() is
-/// well-defined.
-template <typename T> struct alignas(T) SmallVectorStorage<T, 0> {};
-
-/// Forward declaration of SmallVector so that
-/// calculateSmallVectorDefaultInlinedElements can reference
-/// `sizeof(SmallVector<T, 0>)`.
-template <typename T, unsigned N> class LLVM_GSL_OWNER SmallVector;
-
-/// Helper class for calculating the default number of inline elements for
-/// `SmallVector<T>`.
-///
-/// This should be migrated to a constexpr function when our minimum
-/// compiler support is enough for multi-statement constexpr functions.
-template <typename T> struct CalculateSmallVectorDefaultInlinedElements {
-  // Parameter controlling the default number of inlined elements
-  // for `SmallVector<T>`.
-  //
-  // The default number of inlined elements ensures that
-  // 1. There is at least one inlined element.
-  // 2. `sizeof(SmallVector<T>) <= kPreferredSmallVectorSizeof` unless
-  // it contradicts 1.
-  static constexpr size_t kPreferredSmallVectorSizeof = 64;
-
-  // static_assert that sizeof(T) is not "too big".
-  //
-  // Because our policy guarantees at least one inlined element, it is possible
-  // for an arbitrarily large inlined element to allocate an arbitrarily large
-  // amount of inline storage. We generally consider it an antipattern for a
-  // SmallVector to allocate an excessive amount of inline storage, so we want
-  // to call attention to these cases and make sure that users are making an
-  // intentional decision if they request a lot of inline storage.
-  //
-  // We want this assertion to trigger in pathological cases, but otherwise
-  // not be too easy to hit. To accomplish that, the cutoff is actually somewhat
-  // larger than kPreferredSmallVectorSizeof (otherwise,
-  // `SmallVector<SmallVector<T>>` would be one easy way to trip it, and that
-  // pattern seems useful in practice).
-  //
-  // One wrinkle is that this assertion is in theory non-portable, since
-  // sizeof(T) is in general platform-dependent. However, we don't expect this
-  // to be much of an issue, because most LLVM development happens on 64-bit
-  // hosts, and therefore sizeof(T) is expected to *decrease* when compiled for
-  // 32-bit hosts, dodging the issue. The reverse situation, where development
-  // happens on a 32-bit host and then fails due to sizeof(T) *increasing* on a
-  // 64-bit host, is expected to be very rare.
-  static_assert(
-      sizeof(T) <= 256,
-      "You are trying to use a default number of inlined elements for "
-      "`SmallVector<T>` but `sizeof(T)` is really big! Please use an "
-      "explicit number of inlined elements with `SmallVector<T, N>` to make "
-      "sure you really want that much inline storage.");
-
-  // Discount the size of the header itself when calculating the maximum inline
-  // bytes.
-  static constexpr size_t PreferredInlineBytes =
-      kPreferredSmallVectorSizeof - sizeof(SmallVector<T, 0>);
-  static constexpr size_t NumElementsThatFit = PreferredInlineBytes / sizeof(T);
-  static constexpr size_t value =
-      NumElementsThatFit == 0 ? 1 : NumElementsThatFit;
-};
-
-/// This is a 'vector' (really, a variable-sized array), optimized
-/// for the case when the array is small.  It contains some number of elements
-/// in-place, which allows it to avoid heap allocation when the actual number of
-/// elements is below that threshold.  This allows normal "small" cases to be
-/// fast without losing generality for large inputs.
-///
-/// \note
-/// In the absence of a well-motivated choice for the number of inlined
-/// elements \p N, it is recommended to use \c SmallVector<T> (that is,
-/// omitting the \p N). This will choose a default number of inlined elements
-/// reasonable for allocation on the stack (for example, trying to keep \c
-/// sizeof(SmallVector<T>) around 64 bytes).
-///
-/// \warning This does not attempt to be exception safe.
-///
-/// \see https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h
-template <typename T,
-          unsigned N = CalculateSmallVectorDefaultInlinedElements<T>::value>
-class LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
-                                   SmallVectorStorage<T, N> {
-public:
-  SmallVector() : SmallVectorImpl<T>(N) {}
-
-  ~SmallVector() {
-    // Destroy the constructed elements in the vector.
-    this->destroy_range(this->begin(), this->end());
-  }
-
-  explicit SmallVector(size_t Size, const T &Value = T())
-    : SmallVectorImpl<T>(N) {
-    this->assign(Size, Value);
-  }
-
-  template <typename ItTy,
-            typename = std::enable_if_t<std::is_convertible<
-                typename std::iterator_traits<ItTy>::iterator_category,
-                std::input_iterator_tag>::value>>
-  SmallVector(ItTy S, ItTy E) : SmallVectorImpl<T>(N) {
-    this->append(S, E);
-  }
-
-  template <typename RangeTy>
-  explicit SmallVector(const iterator_range<RangeTy> &R)
-      : SmallVectorImpl<T>(N) {
-    this->append(R.begin(), R.end());
-  }
-
-  SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
-    this->assign(IL);
-  }
-
-  SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(N) {
-    if (!RHS.empty())
-      SmallVectorImpl<T>::operator=(RHS);
-  }
-
-  SmallVector &operator=(const SmallVector &RHS) {
-    SmallVectorImpl<T>::operator=(RHS);
-    return *this;
-  }
-
-  SmallVector(SmallVector &&RHS) : SmallVectorImpl<T>(N) {
-    if (!RHS.empty())
-      SmallVectorImpl<T>::operator=(::std::move(RHS));
-  }
-
-  SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
-    if (!RHS.empty())
-      SmallVectorImpl<T>::operator=(::std::move(RHS));
-  }
-
-  SmallVector &operator=(SmallVector &&RHS) {
-    SmallVectorImpl<T>::operator=(::std::move(RHS));
-    return *this;
-  }
-
-  SmallVector &operator=(SmallVectorImpl<T> &&RHS) {
-    SmallVectorImpl<T>::operator=(::std::move(RHS));
-    return *this;
-  }
-
-  SmallVector &operator=(std::initializer_list<T> IL) {
-    this->assign(IL);
-    return *this;
-  }
-};
-
-template <typename T, unsigned N>
-inline size_t capacity_in_bytes(const SmallVector<T, N> &X) {
-  return X.capacity_in_bytes();
-}
-
-/// Given a range of type R, iterate the entire range and return a
-/// SmallVector with elements of the vector.  This is useful, for example,
-/// when you want to iterate a range and then sort the results.
-template <unsigned Size, typename R>
-SmallVector<typename std::remove_const<typename std::remove_reference<
-                decltype(*std::begin(std::declval<R &>()))>::type>::type,
-            Size>
-to_vector(R &&Range) {
-  return {std::begin(Range), std::end(Range)};
-}
-
-} // end namespace llvm
-
-namespace std {
-
-  /// Implement std::swap in terms of SmallVector swap.
-  template<typename T>
-  inline void
-  swap(llvm::SmallVectorImpl<T> &LHS, llvm::SmallVectorImpl<T> &RHS) {
-    LHS.swap(RHS);
-  }
-
-  /// Implement std::swap in terms of SmallVector swap.
-  template<typename T, unsigned N>
-  inline void
-  swap(llvm::SmallVector<T, N> &LHS, llvm::SmallVector<T, N> &RHS) {
-    LHS.swap(RHS);
-  }
-
-} // end namespace std
-
-#endif // LLVM_ADT_SMALLVECTOR_H
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/StringRef.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/StringRef.h
index 17e64f7f8..049f22b03 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/ADT/StringRef.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/ADT/StringRef.h
@@ -9,7 +9,8 @@
 #ifndef LLVM_ADT_STRINGREF_H
 #define LLVM_ADT_STRINGREF_H
 
-#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Compiler.h"
 #include <algorithm>
@@ -18,24 +19,15 @@
 #include <cstring>
 #include <limits>
 #include <string>
-#if __cplusplus > 201402L
 #include <string_view>
-#endif
 #include <type_traits>
 #include <utility>
 
-// Declare the __builtin_strlen intrinsic for MSVC so it can be used in
-// constexpr context.
-#if defined(_MSC_VER)
-extern "C" size_t __builtin_strlen(const char *);
-#endif
-
 namespace llvm {
 
   class APInt;
   class hash_code;
   template <typename T> class SmallVectorImpl;
-  template <typename T> struct DenseMapInfo;
   class StringRef;
 
   /// Helper functions for StringRef::getAsInteger.
@@ -77,21 +69,6 @@ namespace llvm {
       return ::memcmp(Lhs,Rhs,Length);
     }
 
-    // Constexpr version of std::strlen.
-    static constexpr size_t strLen(const char *Str) {
-#if __cplusplus > 201402L
-      return std::char_traits<char>::length(Str);
-#elif __has_builtin(__builtin_strlen) || defined(__GNUC__) || \
-    (defined(_MSC_VER) && _MSC_VER >= 1916)
-      return __builtin_strlen(Str);
-#else
-      const char *Begin = Str;
-      while (*Str != '\0')
-        ++Str;
-      return Str - Begin;
-#endif
-    }
-
   public:
     /// @name Constructors
     /// @{
@@ -105,7 +82,15 @@ namespace llvm {
 
     /// Construct a string ref from a cstring.
     /*implicit*/ constexpr StringRef(const char *Str)
-        : Data(Str), Length(Str ? strLen(Str) : 0) {}
+        : Data(Str), Length(Str ?
+    // GCC 7 doesn't have constexpr char_traits. Fall back to __builtin_strlen.
+#if defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE < 8
+                                __builtin_strlen(Str)
+#else
+                                std::char_traits<char>::length(Str)
+#endif
+                                : 0) {
+    }
 
     /// Construct a string ref from a pointer and length.
     /*implicit*/ constexpr StringRef(const char *data, size_t length)
@@ -115,11 +100,9 @@ namespace llvm {
     /*implicit*/ StringRef(const std::string &Str)
       : Data(Str.data()), Length(Str.length()) {}
 
-#if __cplusplus > 201402L
     /// Construct a string ref from an std::string_view.
     /*implicit*/ constexpr StringRef(std::string_view Str)
         : Data(Str.data()), Length(Str.size()) {}
-#endif
 
     /// @}
     /// @name Iterators
@@ -145,34 +128,29 @@ namespace llvm {
 
     /// data - Get a pointer to the start of the string (which may not be null
     /// terminated).
-    LLVM_NODISCARD
-    const char *data() const { return Data; }
+    [[nodiscard]] constexpr const char *data() const { return Data; }
 
     /// empty - Check if the string is empty.
-    LLVM_NODISCARD
-    bool empty() const { return Length == 0; }
+    [[nodiscard]] constexpr bool empty() const { return Length == 0; }
 
     /// size - Get the string size.
-    LLVM_NODISCARD
-    size_t size() const { return Length; }
+    [[nodiscard]] constexpr size_t size() const { return Length; }
 
     /// front - Get the first character in the string.
-    LLVM_NODISCARD
-    char front() const {
+    [[nodiscard]] char front() const {
       assert(!empty());
       return Data[0];
     }
 
     /// back - Get the last character in the string.
-    LLVM_NODISCARD
-    char back() const {
+    [[nodiscard]] char back() const {
       assert(!empty());
       return Data[Length-1];
     }
 
     // copy - Allocate copy in Allocator and return StringRef to it.
     template <typename Allocator>
-    LLVM_NODISCARD StringRef copy(Allocator &A) const {
+    [[nodiscard]] StringRef copy(Allocator &A) const {
       // Don't request a length 0 copy from the allocator.
       if (empty())
         return StringRef();
@@ -181,24 +159,15 @@ namespace llvm {
       return StringRef(S, Length);
     }
 
-    /// equals - Check for string equality, this is more efficient than
-    /// compare() when the relative ordering of inequal strings isn't needed.
-    LLVM_NODISCARD
-    bool equals(StringRef RHS) const {
-      return (Length == RHS.Length &&
-              compareMemory(Data, RHS.Data, RHS.Length) == 0);
-    }
-
     /// Check for string equality, ignoring case.
-    LLVM_NODISCARD
-    bool equals_insensitive(StringRef RHS) const {
+    [[nodiscard]] bool equals_insensitive(StringRef RHS) const {
       return Length == RHS.Length && compare_insensitive(RHS) == 0;
     }
 
-    /// compare - Compare two strings; the result is -1, 0, or 1 if this string
-    /// is lexicographically less than, equal to, or greater than the \p RHS.
-    LLVM_NODISCARD
-    int compare(StringRef RHS) const {
+    /// compare - Compare two strings; the result is negative, zero, or positive
+    /// if this string is lexicographically less than, equal to, or greater than
+    /// the \p RHS.
+    [[nodiscard]] int compare(StringRef RHS) const {
       // Check the prefix for a mismatch.
       if (int Res = compareMemory(Data, RHS.Data, std::min(Length, RHS.Length)))
         return Res < 0 ? -1 : 1;
@@ -210,13 +179,11 @@ namespace llvm {
     }
 
     /// Compare two strings, ignoring case.
-    LLVM_NODISCARD
-    int compare_insensitive(StringRef RHS) const;
+    [[nodiscard]] int compare_insensitive(StringRef RHS) const;
 
     /// compare_numeric - Compare two strings, treating sequences of digits as
     /// numbers.
-    LLVM_NODISCARD
-    int compare_numeric(StringRef RHS) const;
+    [[nodiscard]] int compare_numeric(StringRef RHS) const;
 
     /// Determine the edit distance between this string and another
     /// string.
@@ -236,13 +203,16 @@ namespace llvm {
     /// or (if \p AllowReplacements is \c true) replacements needed to
     /// transform one of the given strings into the other. If zero,
     /// the strings are identical.
-    LLVM_NODISCARD
-    unsigned edit_distance(StringRef Other, bool AllowReplacements = true,
-                           unsigned MaxEditDistance = 0) const;
+    [[nodiscard]] unsigned edit_distance(StringRef Other,
+                                         bool AllowReplacements = true,
+                                         unsigned MaxEditDistance = 0) const;
+
+    [[nodiscard]] unsigned
+    edit_distance_insensitive(StringRef Other, bool AllowReplacements = true,
+                              unsigned MaxEditDistance = 0) const;
 
     /// str - Get the contents as an std::string.
-    LLVM_NODISCARD
-    std::string str() const {
+    [[nodiscard]] std::string str() const {
       if (!Data) return std::string();
       return std::string(Data, Length);
     }
@@ -251,8 +221,7 @@ namespace llvm {
     /// @name Operator Overloads
     /// @{
 
-    LLVM_NODISCARD
-    char operator[](size_t Index) const {
+    [[nodiscard]] char operator[](size_t Index) const {
       assert(Index < Length && "Invalid index!");
       return Data[Index];
     }
@@ -269,39 +238,38 @@ namespace llvm {
     /// @name Type Conversions
     /// @{
 
-    explicit operator std::string() const { return str(); }
-
-#if __cplusplus > 201402L
-    operator std::string_view() const {
+    constexpr operator std::string_view() const {
       return std::string_view(data(), size());
     }
-#endif
 
     /// @}
     /// @name String Predicates
     /// @{
 
     /// Check if this string starts with the given \p Prefix.
-    LLVM_NODISCARD
-    bool startswith(StringRef Prefix) const {
+    [[nodiscard]] bool starts_with(StringRef Prefix) const {
       return Length >= Prefix.Length &&
              compareMemory(Data, Prefix.Data, Prefix.Length) == 0;
     }
+    [[nodiscard]] bool starts_with(char Prefix) const {
+      return !empty() && front() == Prefix;
+    }
 
     /// Check if this string starts with the given \p Prefix, ignoring case.
-    LLVM_NODISCARD
-    bool startswith_insensitive(StringRef Prefix) const;
+    [[nodiscard]] bool starts_with_insensitive(StringRef Prefix) const;
 
     /// Check if this string ends with the given \p Suffix.
-    LLVM_NODISCARD
-    bool endswith(StringRef Suffix) const {
+    [[nodiscard]] bool ends_with(StringRef Suffix) const {
       return Length >= Suffix.Length &&
-        compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
+             compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) ==
+                 0;
+    }
+    [[nodiscard]] bool ends_with(char Suffix) const {
+      return !empty() && back() == Suffix;
     }
 
     /// Check if this string ends with the given \p Suffix, ignoring case.
-    LLVM_NODISCARD
-    bool endswith_insensitive(StringRef Suffix) const;
+    [[nodiscard]] bool ends_with_insensitive(StringRef Suffix) const;
 
     /// @}
     /// @name String Searching
@@ -311,30 +279,22 @@ namespace llvm {
     ///
     /// \returns The index of the first occurrence of \p C, or npos if not
     /// found.
-    LLVM_NODISCARD
-    size_t find(char C, size_t From = 0) const {
-      size_t FindBegin = std::min(From, Length);
-      if (FindBegin < Length) { // Avoid calling memchr with nullptr.
-        // Just forward to memchr, which is faster than a hand-rolled loop.
-        if (const void *P = ::memchr(Data + FindBegin, C, Length - FindBegin))
-          return static_cast<const char *>(P) - Data;
-      }
-      return npos;
+    [[nodiscard]] size_t find(char C, size_t From = 0) const {
+      return std::string_view(*this).find(C, From);
     }
 
     /// Search for the first character \p C in the string, ignoring case.
     ///
     /// \returns The index of the first occurrence of \p C, or npos if not
     /// found.
-    LLVM_NODISCARD
-    size_t find_insensitive(char C, size_t From = 0) const;
+    [[nodiscard]] size_t find_insensitive(char C, size_t From = 0) const;
 
     /// Search for the first character satisfying the predicate \p F
     ///
     /// \returns The index of the first character satisfying \p F starting from
     /// \p From, or npos if not found.
-    LLVM_NODISCARD
-    size_t find_if(function_ref<bool(char)> F, size_t From = 0) const {
+    [[nodiscard]] size_t find_if(function_ref<bool(char)> F,
+                                 size_t From = 0) const {
       StringRef S = drop_front(From);
       while (!S.empty()) {
         if (F(S.front()))
@@ -348,8 +308,8 @@ namespace llvm {
     ///
     /// \returns The index of the first character not satisfying \p F starting
     /// from \p From, or npos if not found.
-    LLVM_NODISCARD
-    size_t find_if_not(function_ref<bool(char)> F, size_t From = 0) const {
+    [[nodiscard]] size_t find_if_not(function_ref<bool(char)> F,
+                                     size_t From = 0) const {
       return find_if([F](char c) { return !F(c); }, From);
     }
 
@@ -357,28 +317,24 @@ namespace llvm {
     ///
     /// \returns The index of the first occurrence of \p Str, or npos if not
     /// found.
-    LLVM_NODISCARD
-    size_t find(StringRef Str, size_t From = 0) const;
+    [[nodiscard]] size_t find(StringRef Str, size_t From = 0) const;
 
     /// Search for the first string \p Str in the string, ignoring case.
     ///
     /// \returns The index of the first occurrence of \p Str, or npos if not
     /// found.
-    LLVM_NODISCARD
-    size_t find_insensitive(StringRef Str, size_t From = 0) const;
+    [[nodiscard]] size_t find_insensitive(StringRef Str, size_t From = 0) const;
 
     /// Search for the last character \p C in the string.
     ///
     /// \returns The index of the last occurrence of \p C, or npos if not
     /// found.
-    LLVM_NODISCARD
-    size_t rfind(char C, size_t From = npos) const {
-      From = std::min(From, Length);
-      size_t i = From;
-      while (i != 0) {
-        --i;
-        if (Data[i] == C)
-          return i;
+    [[nodiscard]] size_t rfind(char C, size_t From = npos) const {
+      size_t I = std::min(From, Length);
+      while (I) {
+        --I;
+        if (Data[I] == C)
+          return I;
       }
       return npos;
     }
@@ -387,27 +343,23 @@ namespace llvm {
     ///
     /// \returns The index of the last occurrence of \p C, or npos if not
     /// found.
-    LLVM_NODISCARD
-    size_t rfind_insensitive(char C, size_t From = npos) const;
+    [[nodiscard]] size_t rfind_insensitive(char C, size_t From = npos) const;
 
     /// Search for the last string \p Str in the string.
     ///
     /// \returns The index of the last occurrence of \p Str, or npos if not
     /// found.
-    LLVM_NODISCARD
-    size_t rfind(StringRef Str) const;
+    [[nodiscard]] size_t rfind(StringRef Str) const;
 
     /// Search for the last string \p Str in the string, ignoring case.
     ///
     /// \returns The index of the last occurrence of \p Str, or npos if not
     /// found.
-    LLVM_NODISCARD
-    size_t rfind_insensitive(StringRef Str) const;
+    [[nodiscard]] size_t rfind_insensitive(StringRef Str) const;
 
     /// Find the first character in the string that is \p C, or npos if not
     /// found. Same as find.
-    LLVM_NODISCARD
-    size_t find_first_of(char C, size_t From = 0) const {
+    [[nodiscard]] size_t find_first_of(char C, size_t From = 0) const {
       return find(C, From);
     }
 
@@ -415,25 +367,22 @@ namespace llvm {
     /// not found.
     ///
     /// Complexity: O(size() + Chars.size())
-    LLVM_NODISCARD
-    size_t find_first_of(StringRef Chars, size_t From = 0) const;
+    [[nodiscard]] size_t find_first_of(StringRef Chars, size_t From = 0) const;
 
     /// Find the first character in the string that is not \p C or npos if not
     /// found.
-    LLVM_NODISCARD
-    size_t find_first_not_of(char C, size_t From = 0) const;
+    [[nodiscard]] size_t find_first_not_of(char C, size_t From = 0) const;
 
     /// Find the first character in the string that is not in the string
     /// \p Chars, or npos if not found.
     ///
     /// Complexity: O(size() + Chars.size())
-    LLVM_NODISCARD
-    size_t find_first_not_of(StringRef Chars, size_t From = 0) const;
+    [[nodiscard]] size_t find_first_not_of(StringRef Chars,
+                                           size_t From = 0) const;
 
     /// Find the last character in the string that is \p C, or npos if not
     /// found.
-    LLVM_NODISCARD
-    size_t find_last_of(char C, size_t From = npos) const {
+    [[nodiscard]] size_t find_last_of(char C, size_t From = npos) const {
       return rfind(C, From);
     }
 
@@ -441,42 +390,41 @@ namespace llvm {
     /// found.
     ///
     /// Complexity: O(size() + Chars.size())
-    LLVM_NODISCARD
-    size_t find_last_of(StringRef Chars, size_t From = npos) const;
+    [[nodiscard]] size_t find_last_of(StringRef Chars,
+                                      size_t From = npos) const;
 
     /// Find the last character in the string that is not \p C, or npos if not
     /// found.
-    LLVM_NODISCARD
-    size_t find_last_not_of(char C, size_t From = npos) const;
+    [[nodiscard]] size_t find_last_not_of(char C, size_t From = npos) const;
 
     /// Find the last character in the string that is not in \p Chars, or
     /// npos if not found.
     ///
     /// Complexity: O(size() + Chars.size())
-    LLVM_NODISCARD
-    size_t find_last_not_of(StringRef Chars, size_t From = npos) const;
+    [[nodiscard]] size_t find_last_not_of(StringRef Chars,
+                                          size_t From = npos) const;
 
     /// Return true if the given string is a substring of *this, and false
     /// otherwise.
-    LLVM_NODISCARD
-    bool contains(StringRef Other) const { return find(Other) != npos; }
+    [[nodiscard]] bool contains(StringRef Other) const {
+      return find(Other) != npos;
+    }
 
     /// Return true if the given character is contained in *this, and false
     /// otherwise.
-    LLVM_NODISCARD
-    bool contains(char C) const { return find_first_of(C) != npos; }
+    [[nodiscard]] bool contains(char C) const {
+      return find_first_of(C) != npos;
+    }
 
     /// Return true if the given string is a substring of *this, and false
     /// otherwise.
-    LLVM_NODISCARD
-    bool contains_insensitive(StringRef Other) const {
+    [[nodiscard]] bool contains_insensitive(StringRef Other) const {
       return find_insensitive(Other) != npos;
     }
 
     /// Return true if the given character is contained in *this, and false
     /// otherwise.
-    LLVM_NODISCARD
-    bool contains_insensitive(char C) const {
+    [[nodiscard]] bool contains_insensitive(char C) const {
       return find_insensitive(C) != npos;
     }
 
@@ -485,11 +433,10 @@ namespace llvm {
     /// @{
 
     /// Return the number of occurrences of \p C in the string.
-    LLVM_NODISCARD
-    size_t count(char C) const {
+    [[nodiscard]] size_t count(char C) const {
       size_t Count = 0;
-      for (size_t i = 0, e = Length; i != e; ++i)
-        if (Data[i] == C)
+      for (size_t I = 0; I != Length; ++I)
+        if (Data[I] == C)
           ++Count;
       return Count;
     }
@@ -505,28 +452,23 @@ namespace llvm {
     /// If the string is invalid or if only a subset of the string is valid,
     /// this returns true to signify the error.  The string is considered
     /// erroneous if empty or if it overflows T.
-    template <typename T>
-    std::enable_if_t<std::numeric_limits<T>::is_signed, bool>
-    getAsInteger(unsigned Radix, T &Result) const {
-      long long LLVal;
-      if (getAsSignedInteger(*this, Radix, LLVal) ||
+    template <typename T> bool getAsInteger(unsigned Radix, T &Result) const {
+      if constexpr (std::numeric_limits<T>::is_signed) {
+        long long LLVal;
+        if (getAsSignedInteger(*this, Radix, LLVal) ||
             static_cast<T>(LLVal) != LLVal)
-        return true;
-      Result = LLVal;
-      return false;
-    }
-
-    template <typename T>
-    std::enable_if_t<!std::numeric_limits<T>::is_signed, bool>
-    getAsInteger(unsigned Radix, T &Result) const {
-      unsigned long long ULLVal;
-      // The additional cast to unsigned long long is required to avoid the
-      // Visual C++ warning C4805: '!=' : unsafe mix of type 'bool' and type
-      // 'unsigned __int64' when instantiating getAsInteger with T = bool.
-      if (getAsUnsignedInteger(*this, Radix, ULLVal) ||
-          static_cast<unsigned long long>(static_cast<T>(ULLVal)) != ULLVal)
-        return true;
-      Result = ULLVal;
+          return true;
+        Result = LLVal;
+      } else {
+        unsigned long long ULLVal;
+        // The additional cast to unsigned long long is required to avoid the
+        // Visual C++ warning C4805: '!=' : unsafe mix of type 'bool' and type
+        // 'unsigned __int64' when instantiating getAsInteger with T = bool.
+        if (getAsUnsignedInteger(*this, Radix, ULLVal) ||
+            static_cast<unsigned long long>(static_cast<T>(ULLVal)) != ULLVal)
+          return true;
+        Result = ULLVal;
+      }
       return false;
     }
 
@@ -539,25 +481,20 @@ namespace llvm {
     /// erroneous if empty or if it overflows T.
     /// The portion of the string representing the discovered numeric value
     /// is removed from the beginning of the string.
-    template <typename T>
-    std::enable_if_t<std::numeric_limits<T>::is_signed, bool>
-    consumeInteger(unsigned Radix, T &Result) {
-      long long LLVal;
-      if (consumeSignedInteger(*this, Radix, LLVal) ||
-          static_cast<long long>(static_cast<T>(LLVal)) != LLVal)
-        return true;
-      Result = LLVal;
-      return false;
-    }
-
-    template <typename T>
-    std::enable_if_t<!std::numeric_limits<T>::is_signed, bool>
-    consumeInteger(unsigned Radix, T &Result) {
-      unsigned long long ULLVal;
-      if (consumeUnsignedInteger(*this, Radix, ULLVal) ||
-          static_cast<unsigned long long>(static_cast<T>(ULLVal)) != ULLVal)
-        return true;
-      Result = ULLVal;
+    template <typename T> bool consumeInteger(unsigned Radix, T &Result) {
+      if constexpr (std::numeric_limits<T>::is_signed) {
+        long long LLVal;
+        if (consumeSignedInteger(*this, Radix, LLVal) ||
+            static_cast<long long>(static_cast<T>(LLVal)) != LLVal)
+          return true;
+        Result = LLVal;
+      } else {
+        unsigned long long ULLVal;
+        if (consumeUnsignedInteger(*this, Radix, ULLVal) ||
+            static_cast<unsigned long long>(static_cast<T>(ULLVal)) != ULLVal)
+          return true;
+        Result = ULLVal;
+      }
       return false;
     }
 
@@ -573,6 +510,17 @@ namespace llvm {
     /// string is well-formed in the given radix.
     bool getAsInteger(unsigned Radix, APInt &Result) const;
 
+    /// Parse the current string as an integer of the specified \p Radix.  If
+    /// \p Radix is specified as zero, this does radix autosensing using
+    /// extended C rules: 0 is octal, 0x is hex, 0b is binary.
+    ///
+    /// If the string does not begin with a number of the specified radix,
+    /// this returns true to signify the error. The string is considered
+    /// erroneous if empty.
+    /// The portion of the string representing the discovered numeric value
+    /// is removed from the beginning of the string.
+    bool consumeInteger(unsigned Radix, APInt &Result);
+
     /// Parse the current string as an IEEE double-precision floating
     /// point value.  The string must be a well-formed double.
     ///
@@ -587,12 +535,10 @@ namespace llvm {
     /// @{
 
     // Convert the given ASCII string to lowercase.
-    LLVM_NODISCARD
-    std::string lower() const;
+    [[nodiscard]] std::string lower() const;
 
     /// Convert the given ASCII string to uppercase.
-    LLVM_NODISCARD
-    std::string upper() const;
+    [[nodiscard]] std::string upper() const;
 
     /// @}
     /// @name Substring Operations
@@ -607,8 +553,8 @@ namespace llvm {
     /// \param N The number of characters to included in the substring. If N
     /// exceeds the number of characters remaining in the string, the string
     /// suffix (starting with \p Start) will be returned.
-    LLVM_NODISCARD
-    StringRef substr(size_t Start, size_t N = npos) const {
+    [[nodiscard]] constexpr StringRef substr(size_t Start,
+                                             size_t N = npos) const {
       Start = std::min(Start, Length);
       return StringRef(Data + Start, std::min(N, Length - Start));
     }
@@ -616,8 +562,7 @@ namespace llvm {
     /// Return a StringRef equal to 'this' but with only the first \p N
     /// elements remaining.  If \p N is greater than the length of the
     /// string, the entire string is returned.
-    LLVM_NODISCARD
-    StringRef take_front(size_t N = 1) const {
+    [[nodiscard]] StringRef take_front(size_t N = 1) const {
       if (N >= size())
         return *this;
       return drop_back(size() - N);
@@ -626,8 +571,7 @@ namespace llvm {
     /// Return a StringRef equal to 'this' but with only the last \p N
     /// elements remaining.  If \p N is greater than the length of the
     /// string, the entire string is returned.
-    LLVM_NODISCARD
-    StringRef take_back(size_t N = 1) const {
+    [[nodiscard]] StringRef take_back(size_t N = 1) const {
       if (N >= size())
         return *this;
       return drop_front(size() - N);
@@ -635,85 +579,79 @@ namespace llvm {
 
     /// Return the longest prefix of 'this' such that every character
     /// in the prefix satisfies the given predicate.
-    LLVM_NODISCARD
-    StringRef take_while(function_ref<bool(char)> F) const {
+    [[nodiscard]] StringRef take_while(function_ref<bool(char)> F) const {
       return substr(0, find_if_not(F));
     }
 
     /// Return the longest prefix of 'this' such that no character in
     /// the prefix satisfies the given predicate.
-    LLVM_NODISCARD
-    StringRef take_until(function_ref<bool(char)> F) const {
+    [[nodiscard]] StringRef take_until(function_ref<bool(char)> F) const {
       return substr(0, find_if(F));
     }
 
     /// Return a StringRef equal to 'this' but with the first \p N elements
     /// dropped.
-    LLVM_NODISCARD
-    StringRef drop_front(size_t N = 1) const {
+    [[nodiscard]] StringRef drop_front(size_t N = 1) const {
       assert(size() >= N && "Dropping more elements than exist");
       return substr(N);
     }
 
     /// Return a StringRef equal to 'this' but with the last \p N elements
     /// dropped.
-    LLVM_NODISCARD
-    StringRef drop_back(size_t N = 1) const {
+    [[nodiscard]] StringRef drop_back(size_t N = 1) const {
       assert(size() >= N && "Dropping more elements than exist");
       return substr(0, size()-N);
     }
 
     /// Return a StringRef equal to 'this', but with all characters satisfying
     /// the given predicate dropped from the beginning of the string.
-    LLVM_NODISCARD
-    StringRef drop_while(function_ref<bool(char)> F) const {
+    [[nodiscard]] StringRef drop_while(function_ref<bool(char)> F) const {
       return substr(find_if_not(F));
     }
 
     /// Return a StringRef equal to 'this', but with all characters not
     /// satisfying the given predicate dropped from the beginning of the string.
-    LLVM_NODISCARD
-    StringRef drop_until(function_ref<bool(char)> F) const {
+    [[nodiscard]] StringRef drop_until(function_ref<bool(char)> F) const {
       return substr(find_if(F));
     }
 
     /// Returns true if this StringRef has the given prefix and removes that
     /// prefix.
     bool consume_front(StringRef Prefix) {
-      if (!startswith(Prefix))
+      if (!starts_with(Prefix))
         return false;
 
-      *this = drop_front(Prefix.size());
+      *this = substr(Prefix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given prefix, ignoring case,
     /// and removes that prefix.
     bool consume_front_insensitive(StringRef Prefix) {
-      if (!startswith_insensitive(Prefix))
+      if (!starts_with_insensitive(Prefix))
         return false;
 
-      *this = drop_front(Prefix.size());
+      *this = substr(Prefix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given suffix and removes that
     /// suffix.
     bool consume_back(StringRef Suffix) {
-      if (!endswith(Suffix))
+      if (!ends_with(Suffix))
         return false;
 
-      *this = drop_back(Suffix.size());
+      *this = substr(0, size() - Suffix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given suffix, ignoring case,
     /// and removes that suffix.
     bool consume_back_insensitive(StringRef Suffix) {
-      if (!endswith_insensitive(Suffix))
+      if (!ends_with_insensitive(Suffix))
         return false;
 
-      *this = drop_back(Suffix.size());
+      *this = substr(0, size() - Suffix.size());
       return true;
     }
 
@@ -728,10 +666,9 @@ namespace llvm {
     /// remaining in the string, the string suffix (starting with \p Start)
     /// will be returned. If this is less than \p Start, an empty string will
     /// be returned.
-    LLVM_NODISCARD
-    StringRef slice(size_t Start, size_t End) const {
+    [[nodiscard]] StringRef slice(size_t Start, size_t End) const {
       Start = std::min(Start, Length);
-      End = std::min(std::max(Start, End), Length);
+      End = std::clamp(End, Start, Length);
       return StringRef(Data + Start, End - Start);
     }
 
@@ -745,8 +682,7 @@ namespace llvm {
     ///
     /// \param Separator The character to split on.
     /// \returns The split substrings.
-    LLVM_NODISCARD
-    std::pair<StringRef, StringRef> split(char Separator) const {
+    [[nodiscard]] std::pair<StringRef, StringRef> split(char Separator) const {
       return split(StringRef(&Separator, 1));
     }
 
@@ -760,8 +696,8 @@ namespace llvm {
     ///
     /// \param Separator - The string to split on.
     /// \return - The split substrings.
-    LLVM_NODISCARD
-    std::pair<StringRef, StringRef> split(StringRef Separator) const {
+    [[nodiscard]] std::pair<StringRef, StringRef>
+    split(StringRef Separator) const {
       size_t Idx = find(Separator);
       if (Idx == npos)
         return std::make_pair(*this, StringRef());
@@ -778,8 +714,8 @@ namespace llvm {
     ///
     /// \param Separator - The string to split on.
     /// \return - The split substrings.
-    LLVM_NODISCARD
-    std::pair<StringRef, StringRef> rsplit(StringRef Separator) const {
+    [[nodiscard]] std::pair<StringRef, StringRef>
+    rsplit(StringRef Separator) const {
       size_t Idx = rfind(Separator);
       if (Idx == npos)
         return std::make_pair(*this, StringRef());
@@ -831,53 +767,64 @@ namespace llvm {
     ///
     /// \param Separator - The character to split on.
     /// \return - The split substrings.
-    LLVM_NODISCARD
-    std::pair<StringRef, StringRef> rsplit(char Separator) const {
+    [[nodiscard]] std::pair<StringRef, StringRef> rsplit(char Separator) const {
       return rsplit(StringRef(&Separator, 1));
     }
 
     /// Return string with consecutive \p Char characters starting from the
     /// the left removed.
-    LLVM_NODISCARD
-    StringRef ltrim(char Char) const {
+    [[nodiscard]] StringRef ltrim(char Char) const {
       return drop_front(std::min(Length, find_first_not_of(Char)));
     }
 
     /// Return string with consecutive characters in \p Chars starting from
     /// the left removed.
-    LLVM_NODISCARD
-    StringRef ltrim(StringRef Chars = " \t\n\v\f\r") const {
+    [[nodiscard]] StringRef ltrim(StringRef Chars = " \t\n\v\f\r") const {
       return drop_front(std::min(Length, find_first_not_of(Chars)));
     }
 
     /// Return string with consecutive \p Char characters starting from the
     /// right removed.
-    LLVM_NODISCARD
-    StringRef rtrim(char Char) const {
+    [[nodiscard]] StringRef rtrim(char Char) const {
       return drop_back(Length - std::min(Length, find_last_not_of(Char) + 1));
     }
 
     /// Return string with consecutive characters in \p Chars starting from
     /// the right removed.
-    LLVM_NODISCARD
-    StringRef rtrim(StringRef Chars = " \t\n\v\f\r") const {
+    [[nodiscard]] StringRef rtrim(StringRef Chars = " \t\n\v\f\r") const {
       return drop_back(Length - std::min(Length, find_last_not_of(Chars) + 1));
     }
 
     /// Return string with consecutive \p Char characters starting from the
     /// left and right removed.
-    LLVM_NODISCARD
-    StringRef trim(char Char) const {
+    [[nodiscard]] StringRef trim(char Char) const {
       return ltrim(Char).rtrim(Char);
     }
 
     /// Return string with consecutive characters in \p Chars starting from
     /// the left and right removed.
-    LLVM_NODISCARD
-    StringRef trim(StringRef Chars = " \t\n\v\f\r") const {
+    [[nodiscard]] StringRef trim(StringRef Chars = " \t\n\v\f\r") const {
       return ltrim(Chars).rtrim(Chars);
     }
 
+    /// Detect the line ending style of the string.
+    ///
+    /// If the string contains a line ending, return the line ending character
+    /// sequence that is detected. Otherwise return '\n' for unix line endings.
+    ///
+    /// \return - The line ending character sequence.
+    [[nodiscard]] StringRef detectEOL() const {
+      size_t Pos = find('\r');
+      if (Pos == npos) {
+        // If there is no carriage return, assume unix
+        return "\n";
+      }
+      if (Pos + 1 < Length && Data[Pos + 1] == '\n')
+        return "\r\n"; // Windows
+      if (Pos > 0 && Data[Pos - 1] == '\n')
+        return "\n\r"; // You monster!
+      return "\r";     // Classic Mac
+    }
     /// @}
   };
 
@@ -917,25 +864,29 @@ namespace llvm {
   /// @{
 
   inline bool operator==(StringRef LHS, StringRef RHS) {
-    return LHS.equals(RHS);
+    if (LHS.size() != RHS.size())
+      return false;
+    if (LHS.empty())
+      return true;
+    return ::memcmp(LHS.data(), RHS.data(), LHS.size()) == 0;
   }
 
   inline bool operator!=(StringRef LHS, StringRef RHS) { return !(LHS == RHS); }
 
   inline bool operator<(StringRef LHS, StringRef RHS) {
-    return LHS.compare(RHS) == -1;
+    return LHS.compare(RHS) < 0;
   }
 
   inline bool operator<=(StringRef LHS, StringRef RHS) {
-    return LHS.compare(RHS) != 1;
+    return LHS.compare(RHS) <= 0;
   }
 
   inline bool operator>(StringRef LHS, StringRef RHS) {
-    return LHS.compare(RHS) == 1;
+    return LHS.compare(RHS) > 0;
   }
 
   inline bool operator>=(StringRef LHS, StringRef RHS) {
-    return LHS.compare(RHS) != -1;
+    return LHS.compare(RHS) >= 0;
   }
 
   inline std::string &operator+=(std::string &buffer, StringRef string) {
@@ -945,11 +896,10 @@ namespace llvm {
   /// @}
 
   /// Compute a hash_code for a StringRef.
-  LLVM_NODISCARD
-  hash_code hash_value(StringRef S);
+  [[nodiscard]] hash_code hash_value(StringRef S);
 
   // Provide DenseMapInfo for StringRefs.
-  template <> struct DenseMapInfo<StringRef> {
+  template <> struct DenseMapInfo<StringRef, void> {
     static inline StringRef getEmptyKey() {
       return StringRef(
           reinterpret_cast<const char *>(~static_cast<uintptr_t>(0)), 0);
@@ -960,13 +910,7 @@ namespace llvm {
           reinterpret_cast<const char *>(~static_cast<uintptr_t>(1)), 0);
     }
 
-    static unsigned getHashValue(StringRef Val) {
-      assert(Val.data() != getEmptyKey().data() &&
-             "Cannot hash the empty key!");
-      assert(Val.data() != getTombstoneKey().data() &&
-             "Cannot hash the tombstone key!");
-      return (unsigned)(hash_value(Val));
-    }
+    static unsigned getHashValue(StringRef Val);
 
     static bool isEqual(StringRef LHS, StringRef RHS) {
       if (RHS.data() == getEmptyKey().data())
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/StringSwitch.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/StringSwitch.h
index 726d67c8f..7093da076 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/ADT/StringSwitch.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/ADT/StringSwitch.h
@@ -4,10 +4,11 @@
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //===----------------------------------------------------------------------===/
-//
-//  This file implements the StringSwitch template, which mimics a switch()
-//  statement whose cases are string literals.
-//
+///
+/// \file
+///  This file implements the StringSwitch template, which mimics a switch()
+///  statement whose cases are string literals.
+///
 //===----------------------------------------------------------------------===/
 #ifndef LLVM_ADT_STRINGSWITCH_H
 #define LLVM_ADT_STRINGSWITCH_H
@@ -16,6 +17,7 @@
 #include "llvm/Support/Compiler.h"
 #include <cassert>
 #include <cstring>
+#include <optional>
 
 namespace llvm {
 
@@ -45,7 +47,7 @@ class StringSwitch {
 
   /// The pointer to the result of this switch statement, once known,
   /// null before that.
-  Optional<T> Result;
+  std::optional<T> Result;
 
 public:
   explicit StringSwitch(StringRef S)
@@ -72,14 +74,14 @@ class StringSwitch {
   }
 
   StringSwitch& EndsWith(StringLiteral S, T Value) {
-    if (!Result && Str.endswith(S)) {
+    if (!Result && Str.ends_with(S)) {
       Result = std::move(Value);
     }
     return *this;
   }
 
   StringSwitch& StartsWith(StringLiteral S, T Value) {
-    if (!Result && Str.startswith(S)) {
+    if (!Result && Str.starts_with(S)) {
       Result = std::move(Value);
     }
     return *this;
@@ -145,14 +147,14 @@ class StringSwitch {
   }
 
   StringSwitch &EndsWithLower(StringLiteral S, T Value) {
-    if (!Result && Str.endswith_insensitive(S))
+    if (!Result && Str.ends_with_insensitive(S))
       Result = Value;
 
     return *this;
   }
 
   StringSwitch &StartsWithLower(StringLiteral S, T Value) {
-    if (!Result && Str.startswith_insensitive(S))
+    if (!Result && Str.starts_with_insensitive(S))
       Result = std::move(Value);
 
     return *this;
@@ -177,15 +179,13 @@ class StringSwitch {
     return CaseLower(S0, Value).CasesLower(S1, S2, S3, S4, Value);
   }
 
-  LLVM_NODISCARD
-  R Default(T Value) {
+  [[nodiscard]] R Default(T Value) {
     if (Result)
       return std::move(*Result);
     return Value;
   }
 
-  LLVM_NODISCARD
-  operator R() {
+  [[nodiscard]] operator R() {
     assert(Result && "Fell off the end of a string-switch");
     return std::move(*Result);
   }
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/bit.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/bit.h
new file mode 100644
index 000000000..c42b5e686
--- /dev/null
+++ b/symbolic-demangle/vendor/swift/include/llvm/ADT/bit.h
@@ -0,0 +1,422 @@
+//===-- llvm/ADT/bit.h - C++20 <bit> ----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements the C++20 <bit> header.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_BIT_H
+#define LLVM_ADT_BIT_H
+
+#include "llvm/Support/Compiler.h"
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#if !__has_builtin(__builtin_bit_cast)
+#include <cstring>
+#endif
+
+#if defined(_MSC_VER) && !defined(_DEBUG)
+#include <cstdlib>  // for _byteswap_{ushort,ulong,uint64}
+#endif
+
+#if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) ||            \
+    defined(__Fuchsia__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) ||  \
+    defined(__OpenBSD__) || defined(__DragonFly__)
+#include <endian.h>
+#elif defined(_AIX)
+#include <sys/machine.h>
+#elif defined(__sun)
+/* Solaris provides _BIG_ENDIAN/_LITTLE_ENDIAN selector in sys/types.h */
+#include <sys/types.h>
+#define BIG_ENDIAN 4321
+#define LITTLE_ENDIAN 1234
+#if defined(_BIG_ENDIAN)
+#define BYTE_ORDER BIG_ENDIAN
+#else
+#define BYTE_ORDER LITTLE_ENDIAN
+#endif
+#elif defined(__MVS__)
+#define BIG_ENDIAN 4321
+#define LITTLE_ENDIAN 1234
+#define BYTE_ORDER BIG_ENDIAN
+#else
+#if !defined(BYTE_ORDER) && !defined(_WIN32)
+#include <machine/endian.h>
+#endif
+#endif
+
+#ifdef _MSC_VER
+// Declare these intrinsics manually rather including intrin.h. It's very
+// expensive, and bit.h is popular via MathExtras.h.
+// #include <intrin.h>
+extern "C" {
+unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask);
+unsigned char _BitScanForward64(unsigned long *_Index, unsigned __int64 _Mask);
+unsigned char _BitScanReverse(unsigned long *_Index, unsigned long _Mask);
+unsigned char _BitScanReverse64(unsigned long *_Index, unsigned __int64 _Mask);
+}
+#endif
+
+namespace llvm {
+
+enum class endianness {
+  big,
+  little,
+#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
+  native = big
+#else
+  native = little
+#endif
+};
+
+// This implementation of bit_cast is different from the C++20 one in two ways:
+//  - It isn't constexpr because that requires compiler support.
+//  - It requires trivially-constructible To, to avoid UB in the implementation.
+template <
+    typename To, typename From,
+    typename = std::enable_if_t<sizeof(To) == sizeof(From)>,
+    typename = std::enable_if_t<std::is_trivially_constructible<To>::value>,
+    typename = std::enable_if_t<std::is_trivially_copyable<To>::value>,
+    typename = std::enable_if_t<std::is_trivially_copyable<From>::value>>
+[[nodiscard]] inline To bit_cast(const From &from) noexcept {
+#if __has_builtin(__builtin_bit_cast)
+  return __builtin_bit_cast(To, from);
+#else
+  To to;
+  std::memcpy(&to, &from, sizeof(To));
+  return to;
+#endif
+}
+
+/// Reverses the bytes in the given integer value V.
+template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
+[[nodiscard]] constexpr T byteswap(T V) noexcept {
+  if constexpr (sizeof(T) == 1) {
+    return V;
+  } else if constexpr (sizeof(T) == 2) {
+    uint16_t UV = V;
+#if defined(_MSC_VER) && !defined(_DEBUG)
+    // The DLL version of the runtime lacks these functions (bug!?), but in a
+    // release build they're replaced with BSWAP instructions anyway.
+    return _byteswap_ushort(UV);
+#else
+    uint16_t Hi = UV << 8;
+    uint16_t Lo = UV >> 8;
+    return Hi | Lo;
+#endif
+  } else if constexpr (sizeof(T) == 4) {
+    uint32_t UV = V;
+#if __has_builtin(__builtin_bswap32)
+    return __builtin_bswap32(UV);
+#elif defined(_MSC_VER) && !defined(_DEBUG)
+    return _byteswap_ulong(UV);
+#else
+    uint32_t Byte0 = UV & 0x000000FF;
+    uint32_t Byte1 = UV & 0x0000FF00;
+    uint32_t Byte2 = UV & 0x00FF0000;
+    uint32_t Byte3 = UV & 0xFF000000;
+    return (Byte0 << 24) | (Byte1 << 8) | (Byte2 >> 8) | (Byte3 >> 24);
+#endif
+  } else if constexpr (sizeof(T) == 8) {
+    uint64_t UV = V;
+#if __has_builtin(__builtin_bswap64)
+    return __builtin_bswap64(UV);
+#elif defined(_MSC_VER) && !defined(_DEBUG)
+    return _byteswap_uint64(UV);
+#else
+    uint64_t Hi = llvm::byteswap<uint32_t>(UV);
+    uint32_t Lo = llvm::byteswap<uint32_t>(UV >> 32);
+    return (Hi << 32) | Lo;
+#endif
+  } else {
+    static_assert(!sizeof(T *), "Don't know how to handle the given type.");
+    return 0;
+  }
+}
+
+template <typename T, typename = std::enable_if_t<std::is_unsigned_v<T>>>
+[[nodiscard]] constexpr inline bool has_single_bit(T Value) noexcept {
+  return (Value != 0) && ((Value & (Value - 1)) == 0);
+}
+
+namespace detail {
+template <typename T, std::size_t SizeOfT> struct TrailingZerosCounter {
+  static unsigned count(T Val) {
+    if (!Val)
+      return std::numeric_limits<T>::digits;
+    if (Val & 0x1)
+      return 0;
+
+    // Bisection method.
+    unsigned ZeroBits = 0;
+    T Shift = std::numeric_limits<T>::digits >> 1;
+    T Mask = std::numeric_limits<T>::max() >> Shift;
+    while (Shift) {
+      if ((Val & Mask) == 0) {
+        Val >>= Shift;
+        ZeroBits |= Shift;
+      }
+      Shift >>= 1;
+      Mask >>= Shift;
+    }
+    return ZeroBits;
+  }
+};
+
+#if defined(__GNUC__) || defined(_MSC_VER)
+template <typename T> struct TrailingZerosCounter<T, 4> {
+  static unsigned count(T Val) {
+    if (Val == 0)
+      return 32;
+
+#if __has_builtin(__builtin_ctz) || defined(__GNUC__)
+    return __builtin_ctz(Val);
+#elif defined(_MSC_VER)
+    unsigned long Index;
+    _BitScanForward(&Index, Val);
+    return Index;
+#endif
+  }
+};
+
+#if !defined(_MSC_VER) || defined(_M_X64)
+template <typename T> struct TrailingZerosCounter<T, 8> {
+  static unsigned count(T Val) {
+    if (Val == 0)
+      return 64;
+
+#if __has_builtin(__builtin_ctzll) || defined(__GNUC__)
+    return __builtin_ctzll(Val);
+#elif defined(_MSC_VER)
+    unsigned long Index;
+    _BitScanForward64(&Index, Val);
+    return Index;
+#endif
+  }
+};
+#endif
+#endif
+} // namespace detail
+
+/// Count number of 0's from the least significant bit to the most
+///   stopping at the first 1.
+///
+/// Only unsigned integral types are allowed.
+///
+/// Returns std::numeric_limits<T>::digits on an input of 0.
+template <typename T> [[nodiscard]] int countr_zero(T Val) {
+  static_assert(std::is_unsigned_v<T>,
+                "Only unsigned integral types are allowed.");
+  return llvm::detail::TrailingZerosCounter<T, sizeof(T)>::count(Val);
+}
+
+namespace detail {
+template <typename T, std::size_t SizeOfT> struct LeadingZerosCounter {
+  static unsigned count(T Val) {
+    if (!Val)
+      return std::numeric_limits<T>::digits;
+
+    // Bisection method.
+    unsigned ZeroBits = 0;
+    for (T Shift = std::numeric_limits<T>::digits >> 1; Shift; Shift >>= 1) {
+      T Tmp = Val >> Shift;
+      if (Tmp)
+        Val = Tmp;
+      else
+        ZeroBits |= Shift;
+    }
+    return ZeroBits;
+  }
+};
+
+#if defined(__GNUC__) || defined(_MSC_VER)
+template <typename T> struct LeadingZerosCounter<T, 4> {
+  static unsigned count(T Val) {
+    if (Val == 0)
+      return 32;
+
+#if __has_builtin(__builtin_clz) || defined(__GNUC__)
+    return __builtin_clz(Val);
+#elif defined(_MSC_VER)
+    unsigned long Index;
+    _BitScanReverse(&Index, Val);
+    return Index ^ 31;
+#endif
+  }
+};
+
+#if !defined(_MSC_VER) || defined(_M_X64)
+template <typename T> struct LeadingZerosCounter<T, 8> {
+  static unsigned count(T Val) {
+    if (Val == 0)
+      return 64;
+
+#if __has_builtin(__builtin_clzll) || defined(__GNUC__)
+    return __builtin_clzll(Val);
+#elif defined(_MSC_VER)
+    unsigned long Index;
+    _BitScanReverse64(&Index, Val);
+    return Index ^ 63;
+#endif
+  }
+};
+#endif
+#endif
+} // namespace detail
+
+/// Count number of 0's from the most significant bit to the least
+///   stopping at the first 1.
+///
+/// Only unsigned integral types are allowed.
+///
+/// Returns std::numeric_limits<T>::digits on an input of 0.
+template <typename T> [[nodiscard]] int countl_zero(T Val) {
+  static_assert(std::is_unsigned_v<T>,
+                "Only unsigned integral types are allowed.");
+  return llvm::detail::LeadingZerosCounter<T, sizeof(T)>::count(Val);
+}
+
+/// Count the number of ones from the most significant bit to the first
+/// zero bit.
+///
+/// Ex. countl_one(0xFF0FFF00) == 8.
+/// Only unsigned integral types are allowed.
+///
+/// Returns std::numeric_limits<T>::digits on an input of all ones.
+template <typename T> [[nodiscard]] int countl_one(T Value) {
+  static_assert(std::is_unsigned_v<T>,
+                "Only unsigned integral types are allowed.");
+  return llvm::countl_zero<T>(~Value);
+}
+
+/// Count the number of ones from the least significant bit to the first
+/// zero bit.
+///
+/// Ex. countr_one(0x00FF00FF) == 8.
+/// Only unsigned integral types are allowed.
+///
+/// Returns std::numeric_limits<T>::digits on an input of all ones.
+template <typename T> [[nodiscard]] int countr_one(T Value) {
+  static_assert(std::is_unsigned_v<T>,
+                "Only unsigned integral types are allowed.");
+  return llvm::countr_zero<T>(~Value);
+}
+
+/// Returns the number of bits needed to represent Value if Value is nonzero.
+/// Returns 0 otherwise.
+///
+/// Ex. bit_width(5) == 3.
+template <typename T> [[nodiscard]] int bit_width(T Value) {
+  static_assert(std::is_unsigned_v<T>,
+                "Only unsigned integral types are allowed.");
+  return std::numeric_limits<T>::digits - llvm::countl_zero(Value);
+}
+
+/// Returns the largest integral power of two no greater than Value if Value is
+/// nonzero.  Returns 0 otherwise.
+///
+/// Ex. bit_floor(5) == 4.
+template <typename T> [[nodiscard]] T bit_floor(T Value) {
+  static_assert(std::is_unsigned_v<T>,
+                "Only unsigned integral types are allowed.");
+  if (!Value)
+    return 0;
+  return T(1) << (llvm::bit_width(Value) - 1);
+}
+
+/// Returns the smallest integral power of two no smaller than Value if Value is
+/// nonzero.  Returns 1 otherwise.
+///
+/// Ex. bit_ceil(5) == 8.
+///
+/// The return value is undefined if the input is larger than the largest power
+/// of two representable in T.
+template <typename T> [[nodiscard]] T bit_ceil(T Value) {
+  static_assert(std::is_unsigned_v<T>,
+                "Only unsigned integral types are allowed.");
+  if (Value < 2)
+    return 1;
+  return T(1) << llvm::bit_width<T>(Value - 1u);
+}
+
+namespace detail {
+template <typename T, std::size_t SizeOfT> struct PopulationCounter {
+  static int count(T Value) {
+    // Generic version, forward to 32 bits.
+    static_assert(SizeOfT <= 4, "Not implemented!");
+#if defined(__GNUC__)
+    return (int)__builtin_popcount(Value);
+#else
+    uint32_t v = Value;
+    v = v - ((v >> 1) & 0x55555555);
+    v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
+    return int(((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24);
+#endif
+  }
+};
+
+template <typename T> struct PopulationCounter<T, 8> {
+  static int count(T Value) {
+#if defined(__GNUC__)
+    return (int)__builtin_popcountll(Value);
+#else
+    uint64_t v = Value;
+    v = v - ((v >> 1) & 0x5555555555555555ULL);
+    v = (v & 0x3333333333333333ULL) + ((v >> 2) & 0x3333333333333333ULL);
+    v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
+    return int((uint64_t)(v * 0x0101010101010101ULL) >> 56);
+#endif
+  }
+};
+} // namespace detail
+
+/// Count the number of set bits in a value.
+/// Ex. popcount(0xF000F000) = 8
+/// Returns 0 if the word is zero.
+template <typename T, typename = std::enable_if_t<std::is_unsigned_v<T>>>
+[[nodiscard]] inline int popcount(T Value) noexcept {
+  return detail::PopulationCounter<T, sizeof(T)>::count(Value);
+}
+
+// Forward-declare rotr so that rotl can use it.
+template <typename T, typename = std::enable_if_t<std::is_unsigned_v<T>>>
+[[nodiscard]] constexpr T rotr(T V, int R);
+
+template <typename T, typename = std::enable_if_t<std::is_unsigned_v<T>>>
+[[nodiscard]] constexpr T rotl(T V, int R) {
+  unsigned N = std::numeric_limits<T>::digits;
+
+  R = R % N;
+  if (!R)
+    return V;
+
+  if (R < 0)
+    return llvm::rotr(V, -R);
+
+  return (V << R) | (V >> (N - R));
+}
+
+template <typename T, typename> [[nodiscard]] constexpr T rotr(T V, int R) {
+  unsigned N = std::numeric_limits<T>::digits;
+
+  R = R % N;
+  if (!R)
+    return V;
+
+  if (R < 0)
+    return llvm::rotl(V, -R);
+
+  return (V >> R) | (V << (N - R));
+}
+
+} // namespace llvm
+
+#endif
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/iterator.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/iterator.h
index b3c6608e9..6f0c42fe0 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/ADT/iterator.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/ADT/iterator.h
@@ -35,6 +35,21 @@ namespace llvm {
 /// terms of addition of one. These aren't equivalent for all iterator
 /// categories, and respecting that adds a lot of complexity for little gain.
 ///
+/// Iterators are expected to have const rules analogous to pointers, with a
+/// single, const-qualified operator*() that returns ReferenceT. This matches
+/// the second and third pointers in the following example:
+/// \code
+///   int Value;
+///   { int *I = &Value; }             // ReferenceT 'int&'
+///   { int *const I = &Value; }       // ReferenceT 'int&'; const
+///   { const int *I = &Value; }       // ReferenceT 'const int&'
+///   { const int *const I = &Value; } // ReferenceT 'const int&'; const
+/// \endcode
+/// If an iterator facade returns a handle to its own state, then T (and
+/// PointerT and ReferenceT) should usually be const-qualified. Otherwise, if
+/// clients are expected to modify the handle itself, the field can be declared
+/// mutable or use const_cast.
+///
 /// Classes wishing to use `iterator_facade_base` should implement the following
 /// methods:
 ///
@@ -42,8 +57,7 @@ namespace llvm {
 ///   (All of the following methods)
 ///   - DerivedT &operator=(const DerivedT &R);
 ///   - bool operator==(const DerivedT &R) const;
-///   - const T &operator*() const;
-///   - T &operator*();
+///   - T &operator*() const;
 ///   - DerivedT &operator++();
 ///
 /// Bidirectional Iterators:
@@ -95,6 +109,22 @@ class iterator_facade_base {
     operator ReferenceT() const { return *I; }
   };
 
+  /// A proxy object for computing a pointer via indirecting a copy of a
+  /// reference. This is used in APIs which need to produce a pointer but for
+  /// which the reference might be a temporary. The proxy preserves the
+  /// reference internally and exposes the pointer via a arrow operator.
+  class PointerProxy {
+    friend iterator_facade_base;
+
+    ReferenceT R;
+
+    template <typename RefT>
+    PointerProxy(RefT &&R) : R(std::forward<RefT>(R)) {}
+
+  public:
+    PointerT operator->() const { return &R; }
+  };
+
 public:
   DerivedT operator+(DifferenceTypeT n) const {
     static_assert(std::is_base_of<iterator_facade_base, DerivedT>::value,
@@ -172,19 +202,13 @@ class iterator_facade_base {
     return !(static_cast<const DerivedT &>(*this) < RHS);
   }
 
-  PointerT operator->() { return &static_cast<DerivedT *>(this)->operator*(); }
-  PointerT operator->() const {
-    return &static_cast<const DerivedT *>(this)->operator*();
-  }
-  ReferenceProxy operator[](DifferenceTypeT n) {
-    static_assert(IsRandomAccess,
-                  "Subscripting is only defined for random access iterators.");
-    return ReferenceProxy(static_cast<DerivedT *>(this)->operator+(n));
+  PointerProxy operator->() const {
+    return static_cast<const DerivedT *>(this)->operator*();
   }
   ReferenceProxy operator[](DifferenceTypeT n) const {
     static_assert(IsRandomAccess,
                   "Subscripting is only defined for random access iterators.");
-    return ReferenceProxy(static_cast<const DerivedT *>(this)->operator+(n));
+    return static_cast<const DerivedT *>(this)->operator+(n);
   }
 };
 
@@ -330,8 +354,7 @@ class pointer_iterator
   explicit pointer_iterator(WrappedIteratorT u)
       : pointer_iterator::iterator_adaptor_base(std::move(u)) {}
 
-  T &operator*() { return Ptr = &*this->I; }
-  const T &operator*() const { return Ptr = &*this->I; }
+  T &operator*() const { return Ptr = &*this->I; }
 };
 
 template <typename RangeT, typename WrappedIteratorT =
diff --git a/symbolic-demangle/vendor/swift/include/llvm/ADT/iterator_range.h b/symbolic-demangle/vendor/swift/include/llvm/ADT/iterator_range.h
index a9b46a3aa..6c66def0f 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/ADT/iterator_range.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/ADT/iterator_range.h
@@ -18,10 +18,22 @@
 #ifndef LLVM_ADT_ITERATOR_RANGE_H
 #define LLVM_ADT_ITERATOR_RANGE_H
 
+#include "llvm/ADT/ADL.h"
+#include <type_traits>
 #include <utility>
 
 namespace llvm {
 
+template <typename From, typename To, typename = void>
+struct explicitly_convertible : std::false_type {};
+
+template <typename From, typename To>
+struct explicitly_convertible<
+    From, To,
+    std::void_t<decltype(static_cast<To>(
+        std::declval<std::add_rvalue_reference_t<From>>()))>> : std::true_type {
+};
+
 /// A range adaptor for a pair of iterators.
 ///
 /// This just wraps two iterators into a range-compatible interface. Nothing
@@ -31,12 +43,19 @@ class iterator_range {
   IteratorT begin_iterator, end_iterator;
 
 public:
-  //TODO: Add SFINAE to test that the Container's iterators match the range's
-  //      iterators.
+#if __GNUC__ == 7 || (__GNUC__ == 8 && __GNUC_MINOR__ < 4)
+  // Be careful no to break gcc-7 and gcc-8 < 8.4 on the mlir target.
+  // See https://github.com/llvm/llvm-project/issues/63843
   template <typename Container>
+#else
+  template <
+      typename Container,
+      std::enable_if_t<explicitly_convertible<
+          llvm::detail::IterOfRange<Container>, IteratorT>::value> * = nullptr>
+#endif
   iterator_range(Container &&c)
-  //TODO: Consider ADL/non-member begin/end calls.
-      : begin_iterator(c.begin()), end_iterator(c.end()) {}
+      : begin_iterator(adl_begin(c)), end_iterator(adl_end(c)) {
+  }
   iterator_range(IteratorT begin_iterator, IteratorT end_iterator)
       : begin_iterator(std::move(begin_iterator)),
         end_iterator(std::move(end_iterator)) {}
@@ -46,6 +65,10 @@ class iterator_range {
   bool empty() const { return begin_iterator == end_iterator; }
 };
 
+template <typename Container>
+iterator_range(Container &&)
+    -> iterator_range<llvm::detail::IterOfRange<Container>>;
+
 /// Convenience function for iterating over sub-ranges.
 ///
 /// This provides a bit of syntactic sugar to make using sub-ranges
diff --git a/symbolic-demangle/vendor/swift/include/llvm/Config/abi-breaking.h b/symbolic-demangle/vendor/swift/include/llvm/Config/abi-breaking.h
index eb90be1fe..d7f82e1d0 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/Config/abi-breaking.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/Config/abi-breaking.h
@@ -1,9 +1,9 @@
 /*===------- llvm/Config/abi-breaking.h - llvm configuration -------*- C -*-===*/
 /*                                                                            */
-/* Part of the LLVM Project, under the Apache License v2.0 with LLVM          */
-/* Exceptions.                                                                */
-/* See https://llvm.org/LICENSE.txt for license information.                  */
-/* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    */
+/*                     The LLVM Compiler Infrastructure                       */
+/*                                                                            */
+/* This file is distributed under the University of Illinois Open Source      */
+/* License. See LICENSE.TXT for details.                                      */
 /*                                                                            */
 /*===----------------------------------------------------------------------===*/
 
@@ -13,14 +13,14 @@
 #define LLVM_ABI_BREAKING_CHECKS_H
 
 /* Define to enable checks that alter the LLVM C++ ABI */
-#define LLVM_ENABLE_ABI_BREAKING_CHECKS 1
+#define LLVM_ENABLE_ABI_BREAKING_CHECKS 0
 
 /* Define to enable reverse iteration of unordered llvm containers */
 #define LLVM_ENABLE_REVERSE_ITERATION 0
 
 /* Allow selectively disabling link-time mismatch checking so that header-only
    ADT content from LLVM can be used without linking libSupport. */
-#if !defined(LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING) || !LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING
+#if !LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING
 
 // ABI_BREAKING_CHECKS protection: provides link-time failure when clients build
 // mismatch with LLVM
@@ -34,27 +34,15 @@
 #elif defined(_WIN32) || defined(__CYGWIN__) // Win32 w/o #pragma detect_mismatch
 // FIXME: Implement checks without weak.
 #elif defined(__cplusplus)
-#if !(defined(_AIX) && defined(__GNUC__) && !defined(__clang__))
-#define LLVM_HIDDEN_VISIBILITY __attribute__ ((visibility("hidden")))
-#else
-// GCC on AIX does not support visibility attributes. Symbols are not
-// exported by default on AIX.
-#define LLVM_HIDDEN_VISIBILITY
-#endif
 namespace llvm {
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 extern int EnableABIBreakingChecks;
-LLVM_HIDDEN_VISIBILITY
-__attribute__((weak)) int *VerifyEnableABIBreakingChecks =
-    &EnableABIBreakingChecks;
+__attribute__((weak, visibility ("hidden"))) int *VerifyEnableABIBreakingChecks = &EnableABIBreakingChecks;
 #else
 extern int DisableABIBreakingChecks;
-LLVM_HIDDEN_VISIBILITY
-__attribute__((weak)) int *VerifyDisableABIBreakingChecks =
-    &DisableABIBreakingChecks;
+__attribute__((weak, visibility ("hidden"))) int *VerifyDisableABIBreakingChecks = &DisableABIBreakingChecks;
 #endif
 }
-#undef LLVM_HIDDEN_VISIBILITY
 #endif // _MSC_VER
 
 #endif // LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING
diff --git a/symbolic-demangle/vendor/swift/include/llvm/Config/llvm-config.h b/symbolic-demangle/vendor/swift/include/llvm/Config/llvm-config.h
index f138c9366..dc66633eb 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/Config/llvm-config.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/Config/llvm-config.h
@@ -1,9 +1,9 @@
 /*===------- llvm/Config/llvm-config.h - llvm configuration -------*- C -*-===*/
 /*                                                                            */
-/* Part of the LLVM Project, under the Apache License v2.0 with LLVM          */
-/* Exceptions.                                                                */
-/* See https://llvm.org/LICENSE.txt for license information.                  */
-/* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    */
+/*                     The LLVM Compiler Infrastructure                       */
+/*                                                                            */
+/* This file is distributed under the University of Illinois Open Source      */
+/* License. See LICENSE.TXT for details.                                      */
 /*                                                                            */
 /*===----------------------------------------------------------------------===*/
 
@@ -17,8 +17,11 @@
 /* Define if LLVM_ENABLE_DUMP is enabled */
 /* #undef LLVM_ENABLE_DUMP */
 
+/* Define if we link Polly to the tools */
+/* #undef LINK_POLLY_INTO_TOOLS */
+
 /* Target triple LLVM will generate code for by default */
-#define LLVM_DEFAULT_TARGET_TRIPLE "x86_64-apple-macosx10.9"
+#define LLVM_DEFAULT_TARGET_TRIPLE ""
 
 /* Define if threads enabled */
 #define LLVM_ENABLE_THREADS 1
@@ -27,7 +30,7 @@
 #define LLVM_HAS_ATOMICS 1
 
 /* Host triple LLVM will be executed on */
-#define LLVM_HOST_TRIPLE "x86_64-apple-macosx10.9"
+#define LLVM_HOST_TRIPLE ""
 
 /* LLVM architecture name for the native architecture, if available */
 #define LLVM_NATIVE_ARCH X86
@@ -51,7 +54,9 @@
 #define LLVM_NATIVE_TARGETMC LLVMInitializeX86TargetMC
 
 /* Define if this is Unixish platform */
+#if !defined(LLVM_ON_WIN32)
 #define LLVM_ON_UNIX 1
+#endif
 
 /* Define if we have the Intel JIT API runtime support library */
 #define LLVM_USE_INTEL_JITEVENTS 0
@@ -63,7 +68,7 @@
 #define LLVM_USE_PERF 0
 
 /* Major version of the LLVM API */
-#define LLVM_VERSION_MAJOR 10
+#define LLVM_VERSION_MAJOR 7
 
 /* Minor version of the LLVM API */
 #define LLVM_VERSION_MINOR 0
@@ -72,29 +77,11 @@
 #define LLVM_VERSION_PATCH 0
 
 /* LLVM version string */
-#define LLVM_VERSION_STRING "10.0.0git"
+#define LLVM_VERSION_STRING "7.0.0svn"
 
 /* Whether LLVM records statistics for use with GetStatistics(),
  * PrintStatistics() or PrintStatisticsJSON()
  */
 #define LLVM_FORCE_ENABLE_STATS 0
 
-/* Define if we have z3 and want to build it */
-/* #undef LLVM_WITH_Z3 */
-
-/* Define if LLVM was built with a dependency to the libtensorflow dynamic library */
-/* #undef LLVM_HAVE_TF_API */
-
-/* Define if LLVM was built with a dependency to the tensorflow compiler */
-/* #undef LLVM_HAVE_TF_AOT */
-
-/* Define to 1 if you have the <sysexits.h> header file. */
-#define HAVE_SYSEXITS_H 1
-
-/* Define to 1 to enable the experimental new pass manager by default */
-#define LLVM_ENABLE_NEW_PASS_MANAGER 1
-
-/* Define if the xar_open() function is supported on this platform. */
-#define LLVM_HAVE_LIBXAR 1
-
 #endif
diff --git a/symbolic-demangle/vendor/swift/include/llvm/Support/Casting.h b/symbolic-demangle/vendor/swift/include/llvm/Support/Casting.h
index d6f7793d5..14a32ccd0 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/Support/Casting.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/Support/Casting.h
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the isa<X>(), cast<X>(), dyn_cast<X>(), cast_or_null<X>(),
-// and dyn_cast_or_null<X>() templates.
+// This file defines the isa<X>(), cast<X>(), dyn_cast<X>(),
+// cast_if_present<X>(), and dyn_cast_if_present<X>() templates.
 //
 //===----------------------------------------------------------------------===//
 
@@ -18,50 +18,55 @@
 #include "llvm/Support/type_traits.h"
 #include <cassert>
 #include <memory>
+#include <optional>
 #include <type_traits>
 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
-//                          isa<x> Support Templates
+// simplify_type
 //===----------------------------------------------------------------------===//
 
-// Define a template that can be specialized by smart pointers to reflect the
-// fact that they are automatically dereferenced, and are not involved with the
-// template selection process...  the default implementation is a noop.
-//
-template<typename From> struct simplify_type {
+/// Define a template that can be specialized by smart pointers to reflect the
+/// fact that they are automatically dereferenced, and are not involved with the
+/// template selection process...  the default implementation is a noop.
+// TODO: rename this and/or replace it with other cast traits.
+template <typename From> struct simplify_type {
   using SimpleType = From; // The real type this represents...
 
   // An accessor to get the real value...
   static SimpleType &getSimplifiedValue(From &Val) { return Val; }
 };
 
-template<typename From> struct simplify_type<const From> {
+template <typename From> struct simplify_type<const From> {
   using NonConstSimpleType = typename simplify_type<From>::SimpleType;
-  using SimpleType =
-      typename add_const_past_pointer<NonConstSimpleType>::type;
+  using SimpleType = typename add_const_past_pointer<NonConstSimpleType>::type;
   using RetType =
       typename add_lvalue_reference_if_not_pointer<SimpleType>::type;
 
-  static RetType getSimplifiedValue(const From& Val) {
-    return simplify_type<From>::getSimplifiedValue(const_cast<From&>(Val));
+  static RetType getSimplifiedValue(const From &Val) {
+    return simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val));
   }
 };
 
+// TODO: add this namespace once everyone is switched to using the new
+//       interface.
+// namespace detail {
+
+//===----------------------------------------------------------------------===//
+// isa_impl
+//===----------------------------------------------------------------------===//
+
 // The core of the implementation of isa<X> is here; To and From should be
 // the names of classes.  This template can be specialized to customize the
 // implementation of isa<> without rewriting it from scratch.
-template <typename To, typename From, typename Enabler = void>
-struct isa_impl {
-  static inline bool doit(const From &Val) {
-    return To::classof(&Val);
-  }
+template <typename To, typename From, typename Enabler = void> struct isa_impl {
+  static inline bool doit(const From &Val) { return To::classof(&Val); }
 };
 
-/// Always allow upcasts, and perform no dynamic check for them.
+// Always allow upcasts, and perform no dynamic check for them.
 template <typename To, typename From>
-struct isa_impl<To, From, std::enable_if_t<std::is_base_of<To, From>::value>> {
+struct isa_impl<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> {
   static inline bool doit(const From &) { return true; }
 };
 
@@ -85,103 +90,78 @@ struct isa_impl_cl<To, const std::unique_ptr<From>> {
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, From*> {
+template <typename To, typename From> struct isa_impl_cl<To, From *> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, From*const> {
+template <typename To, typename From> struct isa_impl_cl<To, From *const> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, const From*> {
+template <typename To, typename From> struct isa_impl_cl<To, const From *> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, const From*const> {
+template <typename To, typename From>
+struct isa_impl_cl<To, const From *const> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template<typename To, typename From, typename SimpleFrom>
+template <typename To, typename From, typename SimpleFrom>
 struct isa_impl_wrap {
   // When From != SimplifiedType, we can simplify the type some more by using
   // the simplify_type template.
   static bool doit(const From &Val) {
     return isa_impl_wrap<To, SimpleFrom,
-      typename simplify_type<SimpleFrom>::SimpleType>::doit(
-                          simplify_type<const From>::getSimplifiedValue(Val));
+                         typename simplify_type<SimpleFrom>::SimpleType>::
+        doit(simplify_type<const From>::getSimplifiedValue(Val));
   }
 };
 
-template<typename To, typename FromTy>
+template <typename To, typename FromTy>
 struct isa_impl_wrap<To, FromTy, FromTy> {
   // When From == SimpleType, we are as simple as we are going to get.
   static bool doit(const FromTy &Val) {
-    return isa_impl_cl<To,FromTy>::doit(Val);
+    return isa_impl_cl<To, FromTy>::doit(Val);
   }
 };
 
-// isa<X> - Return true if the parameter to the template is an instance of one
-// of the template type arguments.  Used like this:
-//
-//  if (isa<Type>(myVal)) { ... }
-//  if (isa<Type0, Type1, Type2>(myVal)) { ... }
-//
-template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
-  return isa_impl_wrap<X, const Y,
-                       typename simplify_type<const Y>::SimpleType>::doit(Val);
-}
-
-template <typename First, typename Second, typename... Rest, typename Y>
-LLVM_NODISCARD inline bool isa(const Y &Val) {
-  return isa<First>(Val) || isa<Second, Rest...>(Val);
-}
-
-// isa_and_nonnull<X> - Functionally identical to isa, except that a null value
-// is accepted.
-//
-template <typename... X, class Y>
-LLVM_NODISCARD inline bool isa_and_nonnull(const Y &Val) {
-  if (!Val)
-    return false;
-  return isa<X...>(Val);
-}
-
 //===----------------------------------------------------------------------===//
-//                          cast<x> Support Templates
+// cast_retty + cast_retty_impl
 //===----------------------------------------------------------------------===//
 
-template<class To, class From> struct cast_retty;
+template <class To, class From> struct cast_retty;
 
 // Calculate what type the 'cast' function should return, based on a requested
 // type of To and a source type of From.
-template<class To, class From> struct cast_retty_impl {
-  using ret_type = To &;       // Normal case, return Ty&
+template <class To, class From> struct cast_retty_impl {
+  using ret_type = To &; // Normal case, return Ty&
 };
-template<class To, class From> struct cast_retty_impl<To, const From> {
+template <class To, class From> struct cast_retty_impl<To, const From> {
   using ret_type = const To &; // Normal case, return Ty&
 };
 
-template<class To, class From> struct cast_retty_impl<To, From*> {
-  using ret_type = To *;       // Pointer arg case, return Ty*
+template <class To, class From> struct cast_retty_impl<To, From *> {
+  using ret_type = To *; // Pointer arg case, return Ty*
 };
 
-template<class To, class From> struct cast_retty_impl<To, const From*> {
+template <class To, class From> struct cast_retty_impl<To, const From *> {
   using ret_type = const To *; // Constant pointer arg case, return const Ty*
 };
 
-template<class To, class From> struct cast_retty_impl<To, const From*const> {
+template <class To, class From> struct cast_retty_impl<To, const From *const> {
   using ret_type = const To *; // Constant pointer arg case, return const Ty*
 };
 
@@ -195,212 +175,678 @@ struct cast_retty_impl<To, std::unique_ptr<From>> {
   using ret_type = std::unique_ptr<ResultType>;
 };
 
-template<class To, class From, class SimpleFrom>
-struct cast_retty_wrap {
+template <class To, class From, class SimpleFrom> struct cast_retty_wrap {
   // When the simplified type and the from type are not the same, use the type
   // simplifier to reduce the type, then reuse cast_retty_impl to get the
   // resultant type.
   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
 };
 
-template<class To, class FromTy>
-struct cast_retty_wrap<To, FromTy, FromTy> {
+template <class To, class FromTy> struct cast_retty_wrap<To, FromTy, FromTy> {
   // When the simplified type is equal to the from type, use it directly.
-  using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
+  using ret_type = typename cast_retty_impl<To, FromTy>::ret_type;
 };
 
-template<class To, class From>
-struct cast_retty {
+template <class To, class From> struct cast_retty {
   using ret_type = typename cast_retty_wrap<
       To, From, typename simplify_type<From>::SimpleType>::ret_type;
 };
 
+//===----------------------------------------------------------------------===//
+// cast_convert_val
+//===----------------------------------------------------------------------===//
+
 // Ensure the non-simple values are converted using the simplify_type template
 // that may be specialized by smart pointers...
 //
-template<class To, class From, class SimpleFrom> struct cast_convert_val {
+template <class To, class From, class SimpleFrom> struct cast_convert_val {
   // This is not a simple type, use the template to simplify it...
-  static typename cast_retty<To, From>::ret_type doit(From &Val) {
+  static typename cast_retty<To, From>::ret_type doit(const From &Val) {
     return cast_convert_val<To, SimpleFrom,
-      typename simplify_type<SimpleFrom>::SimpleType>::doit(
-                          simplify_type<From>::getSimplifiedValue(Val));
+                            typename simplify_type<SimpleFrom>::SimpleType>::
+        doit(simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val)));
   }
 };
 
-template<class To, class FromTy> struct cast_convert_val<To,FromTy,FromTy> {
-  // This _is_ a simple type, just cast it.
+template <class To, class FromTy> struct cast_convert_val<To, FromTy, FromTy> {
+  // If it's a reference, switch to a pointer to do the cast and then deref it.
   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
-    typename cast_retty<To, FromTy>::ret_type Res2
-     = (typename cast_retty<To, FromTy>::ret_type)const_cast<FromTy&>(Val);
-    return Res2;
+    return *(std::remove_reference_t<typename cast_retty<To, FromTy>::ret_type>
+                 *)&const_cast<FromTy &>(Val);
   }
 };
 
+template <class To, class FromTy>
+struct cast_convert_val<To, FromTy *, FromTy *> {
+  // If it's a pointer, we can use c-style casting directly.
+  static typename cast_retty<To, FromTy *>::ret_type doit(const FromTy *Val) {
+    return (typename cast_retty<To, FromTy *>::ret_type) const_cast<FromTy *>(
+        Val);
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// is_simple_type
+//===----------------------------------------------------------------------===//
+
 template <class X> struct is_simple_type {
   static const bool value =
-      std::is_same<X, typename simplify_type<X>::SimpleType>::value;
+      std::is_same_v<X, typename simplify_type<X>::SimpleType>;
 };
 
-// cast<X> - Return the argument parameter cast to the specified type.  This
-// casting operator asserts that the type is correct, so it does not return null
-// on failure.  It does not allow a null argument (use cast_or_null for that).
-// It is typically used like this:
-//
-//  cast<Instruction>(myVal)->getParent()
-//
-template <class X, class Y>
-inline std::enable_if_t<!is_simple_type<Y>::value,
-                        typename cast_retty<X, const Y>::ret_type>
-cast(const Y &Val) {
-  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
-  return cast_convert_val<
-      X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
+// } // namespace detail
+
+//===----------------------------------------------------------------------===//
+// CastIsPossible
+//===----------------------------------------------------------------------===//
+
+/// This struct provides a way to check if a given cast is possible. It provides
+/// a static function called isPossible that is used to check if a cast can be
+/// performed. It should be overridden like this:
+///
+/// template<> struct CastIsPossible<foo, bar> {
+///   static inline bool isPossible(const bar &b) {
+///     return bar.isFoo();
+///   }
+/// };
+template <typename To, typename From, typename Enable = void>
+struct CastIsPossible {
+  static inline bool isPossible(const From &f) {
+    return isa_impl_wrap<
+        To, const From,
+        typename simplify_type<const From>::SimpleType>::doit(f);
+  }
+};
+
+// Needed for optional unwrapping. This could be implemented with isa_impl, but
+// we want to implement things in the new method and move old implementations
+// over. In fact, some of the isa_impl templates should be moved over to
+// CastIsPossible.
+template <typename To, typename From>
+struct CastIsPossible<To, std::optional<From>> {
+  static inline bool isPossible(const std::optional<From> &f) {
+    assert(f && "CastIsPossible::isPossible called on a nullopt!");
+    return isa_impl_wrap<
+        To, const From,
+        typename simplify_type<const From>::SimpleType>::doit(*f);
+  }
+};
+
+/// Upcasting (from derived to base) and casting from a type to itself should
+/// always be possible.
+template <typename To, typename From>
+struct CastIsPossible<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> {
+  static inline bool isPossible(const From &f) { return true; }
+};
+
+//===----------------------------------------------------------------------===//
+// Cast traits
+//===----------------------------------------------------------------------===//
+
+/// All of these cast traits are meant to be implementations for useful casts
+/// that users may want to use that are outside the standard behavior. An
+/// example of how to use a special cast called `CastTrait` is:
+///
+/// template<> struct CastInfo<foo, bar> : public CastTrait<foo, bar> {};
+///
+/// Essentially, if your use case falls directly into one of the use cases
+/// supported by a given cast trait, simply inherit your special CastInfo
+/// directly from one of these to avoid having to reimplement the boilerplate
+/// `isPossible/castFailed/doCast/doCastIfPossible`. A cast trait can also
+/// provide a subset of those functions.
+
+/// This cast trait just provides castFailed for the specified `To` type to make
+/// CastInfo specializations more declarative. In order to use this, the target
+/// result type must be `To` and `To` must be constructible from `nullptr`.
+template <typename To> struct NullableValueCastFailed {
+  static To castFailed() { return To(nullptr); }
+};
+
+/// This cast trait just provides the default implementation of doCastIfPossible
+/// to make CastInfo specializations more declarative. The `Derived` template
+/// parameter *must* be provided for forwarding castFailed and doCast.
+template <typename To, typename From, typename Derived>
+struct DefaultDoCastIfPossible {
+  static To doCastIfPossible(From f) {
+    if (!Derived::isPossible(f))
+      return Derived::castFailed();
+    return Derived::doCast(f);
+  }
+};
+
+namespace detail {
+/// A helper to derive the type to use with `Self` for cast traits, when the
+/// provided CRTP derived type is allowed to be void.
+template <typename OptionalDerived, typename Default>
+using SelfType = std::conditional_t<std::is_same_v<OptionalDerived, void>,
+                                    Default, OptionalDerived>;
+} // namespace detail
+
+/// This cast trait provides casting for the specific case of casting to a
+/// value-typed object from a pointer-typed object. Note that `To` must be
+/// nullable/constructible from a pointer to `From` to use this cast.
+template <typename To, typename From, typename Derived = void>
+struct ValueFromPointerCast
+    : public CastIsPossible<To, From *>,
+      public NullableValueCastFailed<To>,
+      public DefaultDoCastIfPossible<
+          To, From *,
+          detail::SelfType<Derived, ValueFromPointerCast<To, From>>> {
+  static inline To doCast(From *f) { return To(f); }
+};
+
+/// This cast trait provides std::unique_ptr casting. It has the semantics of
+/// moving the contents of the input unique_ptr into the output unique_ptr
+/// during the cast. It's also a good example of how to implement a move-only
+/// cast.
+template <typename To, typename From, typename Derived = void>
+struct UniquePtrCast : public CastIsPossible<To, From *> {
+  using Self = detail::SelfType<Derived, UniquePtrCast<To, From>>;
+  using CastResultType = std::unique_ptr<
+      std::remove_reference_t<typename cast_retty<To, From>::ret_type>>;
+
+  static inline CastResultType doCast(std::unique_ptr<From> &&f) {
+    return CastResultType((typename CastResultType::element_type *)f.release());
+  }
+
+  static inline CastResultType castFailed() { return CastResultType(nullptr); }
+
+  static inline CastResultType doCastIfPossible(std::unique_ptr<From> &f) {
+    if (!Self::isPossible(f.get()))
+      return castFailed();
+    return doCast(std::move(f));
+  }
+};
+
+/// This cast trait provides std::optional<T> casting. This means that if you
+/// have a value type, you can cast it to another value type and have dyn_cast
+/// return an std::optional<T>.
+template <typename To, typename From, typename Derived = void>
+struct OptionalValueCast
+    : public CastIsPossible<To, From>,
+      public DefaultDoCastIfPossible<
+          std::optional<To>, From,
+          detail::SelfType<Derived, OptionalValueCast<To, From>>> {
+  static inline std::optional<To> castFailed() { return std::optional<To>{}; }
+
+  static inline std::optional<To> doCast(const From &f) { return To(f); }
+};
+
+/// Provides a cast trait that strips `const` from types to make it easier to
+/// implement a const-version of a non-const cast. It just removes boilerplate
+/// and reduces the amount of code you as the user need to implement. You can
+/// use it like this:
+///
+/// template<> struct CastInfo<foo, bar> {
+///   ...verbose implementation...
+/// };
+///
+/// template<> struct CastInfo<foo, const bar> : public
+///        ConstStrippingForwardingCast<foo, const bar, CastInfo<foo, bar>> {};
+///
+template <typename To, typename From, typename ForwardTo>
+struct ConstStrippingForwardingCast {
+  // Remove the pointer if it exists, then we can get rid of consts/volatiles.
+  using DecayedFrom = std::remove_cv_t<std::remove_pointer_t<From>>;
+  // Now if it's a pointer, add it back. Otherwise, we want a ref.
+  using NonConstFrom =
+      std::conditional_t<std::is_pointer_v<From>, DecayedFrom *, DecayedFrom &>;
+
+  static inline bool isPossible(const From &f) {
+    return ForwardTo::isPossible(const_cast<NonConstFrom>(f));
+  }
+
+  static inline decltype(auto) castFailed() { return ForwardTo::castFailed(); }
+
+  static inline decltype(auto) doCast(const From &f) {
+    return ForwardTo::doCast(const_cast<NonConstFrom>(f));
+  }
+
+  static inline decltype(auto) doCastIfPossible(const From &f) {
+    return ForwardTo::doCastIfPossible(const_cast<NonConstFrom>(f));
+  }
+};
+
+/// Provides a cast trait that uses a defined pointer to pointer cast as a base
+/// for reference-to-reference casts. Note that it does not provide castFailed
+/// and doCastIfPossible because a pointer-to-pointer cast would likely just
+/// return `nullptr` which could cause nullptr dereference. You can use it like
+/// this:
+///
+///   template <> struct CastInfo<foo, bar *> { ... verbose implementation... };
+///
+///   template <>
+///   struct CastInfo<foo, bar>
+///       : public ForwardToPointerCast<foo, bar, CastInfo<foo, bar *>> {};
+///
+template <typename To, typename From, typename ForwardTo>
+struct ForwardToPointerCast {
+  static inline bool isPossible(const From &f) {
+    return ForwardTo::isPossible(&f);
+  }
+
+  static inline decltype(auto) doCast(const From &f) {
+    return *ForwardTo::doCast(&f);
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// CastInfo
+//===----------------------------------------------------------------------===//
+
+/// This struct provides a method for customizing the way a cast is performed.
+/// It inherits from CastIsPossible, to support the case of declaring many
+/// CastIsPossible specializations without having to specialize the full
+/// CastInfo.
+///
+/// In order to specialize different behaviors, specify different functions in
+/// your CastInfo specialization.
+/// For isa<> customization, provide:
+///
+///   `static bool isPossible(const From &f)`
+///
+/// For cast<> customization, provide:
+///
+///  `static To doCast(const From &f)`
+///
+/// For dyn_cast<> and the *_if_present<> variants' customization, provide:
+///
+///  `static To castFailed()` and `static To doCastIfPossible(const From &f)`
+///
+/// Your specialization might look something like this:
+///
+///  template<> struct CastInfo<foo, bar> : public CastIsPossible<foo, bar> {
+///    static inline foo doCast(const bar &b) {
+///      return foo(const_cast<bar &>(b));
+///    }
+///    static inline foo castFailed() { return foo(); }
+///    static inline foo doCastIfPossible(const bar &b) {
+///      if (!CastInfo<foo, bar>::isPossible(b))
+///        return castFailed();
+///      return doCast(b);
+///    }
+///  };
+
+// The default implementations of CastInfo don't use cast traits for now because
+// we need to specify types all over the place due to the current expected
+// casting behavior and the way cast_retty works. New use cases can and should
+// take advantage of the cast traits whenever possible!
+
+template <typename To, typename From, typename Enable = void>
+struct CastInfo : public CastIsPossible<To, From> {
+  using Self = CastInfo<To, From, Enable>;
+
+  using CastReturnType = typename cast_retty<To, From>::ret_type;
+
+  static inline CastReturnType doCast(const From &f) {
+    return cast_convert_val<
+        To, From,
+        typename simplify_type<From>::SimpleType>::doit(const_cast<From &>(f));
+  }
+
+  // This assumes that you can construct the cast return type from `nullptr`.
+  // This is largely to support legacy use cases - if you don't want this
+  // behavior you should specialize CastInfo for your use case.
+  static inline CastReturnType castFailed() { return CastReturnType(nullptr); }
+
+  static inline CastReturnType doCastIfPossible(const From &f) {
+    if (!Self::isPossible(f))
+      return castFailed();
+    return doCast(f);
+  }
+};
+
+/// This struct provides an overload for CastInfo where From has simplify_type
+/// defined. This simply forwards to the appropriate CastInfo with the
+/// simplified type/value, so you don't have to implement both.
+template <typename To, typename From>
+struct CastInfo<To, From, std::enable_if_t<!is_simple_type<From>::value>> {
+  using Self = CastInfo<To, From>;
+  using SimpleFrom = typename simplify_type<From>::SimpleType;
+  using SimplifiedSelf = CastInfo<To, SimpleFrom>;
+
+  static inline bool isPossible(From &f) {
+    return SimplifiedSelf::isPossible(
+        simplify_type<From>::getSimplifiedValue(f));
+  }
+
+  static inline decltype(auto) doCast(From &f) {
+    return SimplifiedSelf::doCast(simplify_type<From>::getSimplifiedValue(f));
+  }
+
+  static inline decltype(auto) castFailed() {
+    return SimplifiedSelf::castFailed();
+  }
+
+  static inline decltype(auto) doCastIfPossible(From &f) {
+    return SimplifiedSelf::doCastIfPossible(
+        simplify_type<From>::getSimplifiedValue(f));
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// Pre-specialized CastInfo
+//===----------------------------------------------------------------------===//
+
+/// Provide a CastInfo specialized for std::unique_ptr.
+template <typename To, typename From>
+struct CastInfo<To, std::unique_ptr<From>> : public UniquePtrCast<To, From> {};
+
+/// Provide a CastInfo specialized for std::optional<From>. It's assumed that if
+/// the input is std::optional<From> that the output can be std::optional<To>.
+/// If that's not the case, specialize CastInfo for your use case.
+template <typename To, typename From>
+struct CastInfo<To, std::optional<From>> : public OptionalValueCast<To, From> {
+};
+
+/// isa<X> - Return true if the parameter to the template is an instance of one
+/// of the template type arguments.  Used like this:
+///
+///  if (isa<Type>(myVal)) { ... }
+///  if (isa<Type0, Type1, Type2>(myVal)) { ... }
+template <typename To, typename From>
+[[nodiscard]] inline bool isa(const From &Val) {
+  return CastInfo<To, const From>::isPossible(Val);
 }
 
-template <class X, class Y>
-inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
-  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
-  return cast_convert_val<X, Y,
-                          typename simplify_type<Y>::SimpleType>::doit(Val);
+template <typename First, typename Second, typename... Rest, typename From>
+[[nodiscard]] inline bool isa(const From &Val) {
+  return isa<First>(Val) || isa<Second, Rest...>(Val);
 }
 
-template <class X, class Y>
-inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
-  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
-  return cast_convert_val<X, Y*,
-                          typename simplify_type<Y*>::SimpleType>::doit(Val);
+/// cast<X> - Return the argument parameter cast to the specified type.  This
+/// casting operator asserts that the type is correct, so it does not return
+/// null on failure.  It does not allow a null argument (use cast_if_present for
+/// that). It is typically used like this:
+///
+///  cast<Instruction>(myVal)->getParent()
+
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) cast(const From &Val) {
+  assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!");
+  return CastInfo<To, const From>::doCast(Val);
 }
 
-template <class X, class Y>
-inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
-cast(std::unique_ptr<Y> &&Val) {
-  assert(isa<X>(Val.get()) && "cast<Ty>() argument of incompatible type!");
-  using ret_type = typename cast_retty<X, std::unique_ptr<Y>>::ret_type;
-  return ret_type(
-      cast_convert_val<X, Y *, typename simplify_type<Y *>::SimpleType>::doit(
-          Val.release()));
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) cast(From &Val) {
+  assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!");
+  return CastInfo<To, From>::doCast(Val);
 }
 
-// cast_or_null<X> - Functionally identical to cast, except that a null value is
-// accepted.
-//
-template <class X, class Y>
-LLVM_NODISCARD inline std::enable_if_t<
-    !is_simple_type<Y>::value, typename cast_retty<X, const Y>::ret_type>
-cast_or_null(const Y &Val) {
-  if (!Val)
-    return nullptr;
-  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
-  return cast<X>(Val);
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) cast(From *Val) {
+  assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!");
+  return CastInfo<To, From *>::doCast(Val);
 }
 
-template <class X, class Y>
-LLVM_NODISCARD inline std::enable_if_t<!is_simple_type<Y>::value,
-                                       typename cast_retty<X, Y>::ret_type>
-cast_or_null(Y &Val) {
-  if (!Val)
-    return nullptr;
-  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
-  return cast<X>(Val);
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) cast(std::unique_ptr<From> &&Val) {
+  assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!");
+  return CastInfo<To, std::unique_ptr<From>>::doCast(std::move(Val));
 }
 
-template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
-cast_or_null(Y *Val) {
-  if (!Val) return nullptr;
-  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
-  return cast<X>(Val);
+//===----------------------------------------------------------------------===//
+// ValueIsPresent
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+constexpr bool IsNullable =
+    std::is_pointer_v<T> || std::is_constructible_v<T, std::nullptr_t>;
+
+/// ValueIsPresent provides a way to check if a value is, well, present. For
+/// pointers, this is the equivalent of checking against nullptr, for Optionals
+/// this is the equivalent of checking hasValue(). It also provides a method for
+/// unwrapping a value (think calling .value() on an optional).
+
+// Generic values can't *not* be present.
+template <typename T, typename Enable = void> struct ValueIsPresent {
+  using UnwrappedType = T;
+  static inline bool isPresent(const T &t) { return true; }
+  static inline decltype(auto) unwrapValue(T &t) { return t; }
+};
+
+// Optional provides its own way to check if something is present.
+template <typename T> struct ValueIsPresent<std::optional<T>> {
+  using UnwrappedType = T;
+  static inline bool isPresent(const std::optional<T> &t) {
+    return t.has_value();
+  }
+  static inline decltype(auto) unwrapValue(std::optional<T> &t) { return *t; }
+};
+
+// If something is "nullable" then we just compare it to nullptr to see if it
+// exists.
+template <typename T>
+struct ValueIsPresent<T, std::enable_if_t<IsNullable<T>>> {
+  using UnwrappedType = T;
+  static inline bool isPresent(const T &t) { return t != T(nullptr); }
+  static inline decltype(auto) unwrapValue(T &t) { return t; }
+};
+
+namespace detail {
+// Convenience function we can use to check if a value is present. Because of
+// simplify_type, we have to call it on the simplified type for now.
+template <typename T> inline bool isPresent(const T &t) {
+  return ValueIsPresent<typename simplify_type<T>::SimpleType>::isPresent(
+      simplify_type<T>::getSimplifiedValue(const_cast<T &>(t)));
 }
 
-template <class X, class Y>
-inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
-cast_or_null(std::unique_ptr<Y> &&Val) {
-  if (!Val)
-    return nullptr;
-  return cast<X>(std::move(Val));
+// Convenience function we can use to unwrap a value.
+template <typename T> inline decltype(auto) unwrapValue(T &t) {
+  return ValueIsPresent<T>::unwrapValue(t);
 }
+} // namespace detail
 
-// dyn_cast<X> - Return the argument parameter cast to the specified type.  This
-// casting operator returns null if the argument is of the wrong type, so it can
-// be used to test for a type as well as cast if successful.  This should be
-// used in the context of an if statement like this:
-//
-//  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
-//
+/// dyn_cast<X> - Return the argument parameter cast to the specified type. This
+/// casting operator returns null if the argument is of the wrong type, so it
+/// can be used to test for a type as well as cast if successful. The value
+/// passed in must be present, if not, use dyn_cast_if_present. This should be
+/// used in the context of an if statement like this:
+///
+///  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
 
-template <class X, class Y>
-LLVM_NODISCARD inline std::enable_if_t<
-    !is_simple_type<Y>::value, typename cast_retty<X, const Y>::ret_type>
-dyn_cast(const Y &Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) dyn_cast(const From &Val) {
+  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value");
+  return CastInfo<To, const From>::doCastIfPossible(Val);
 }
 
-template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) dyn_cast(From &Val) {
+  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value");
+  return CastInfo<To, From>::doCastIfPossible(Val);
 }
 
-template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) dyn_cast(From *Val) {
+  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value");
+  return CastInfo<To, From *>::doCastIfPossible(Val);
 }
 
-// dyn_cast_or_null<X> - Functionally identical to dyn_cast, except that a null
-// value is accepted.
-//
-template <class X, class Y>
-LLVM_NODISCARD inline std::enable_if_t<
-    !is_simple_type<Y>::value, typename cast_retty<X, const Y>::ret_type>
-dyn_cast_or_null(const Y &Val) {
-  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) dyn_cast(std::unique_ptr<From> &Val) {
+  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value");
+  return CastInfo<To, std::unique_ptr<From>>::doCastIfPossible(Val);
+}
+
+/// isa_and_present<X> - Functionally identical to isa, except that a null value
+/// is accepted.
+template <typename... X, class Y>
+[[nodiscard]] inline bool isa_and_present(const Y &Val) {
+  if (!detail::isPresent(Val))
+    return false;
+  return isa<X...>(Val);
+}
+
+template <typename... X, class Y>
+[[nodiscard]] inline bool isa_and_nonnull(const Y &Val) {
+  return isa_and_present<X...>(Val);
 }
 
+/// cast_if_present<X> - Functionally identical to cast, except that a null
+/// value is accepted.
 template <class X, class Y>
-LLVM_NODISCARD inline std::enable_if_t<!is_simple_type<Y>::value,
-                                       typename cast_retty<X, Y>::ret_type>
-dyn_cast_or_null(Y &Val) {
-  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
+[[nodiscard]] inline auto cast_if_present(const Y &Val) {
+  if (!detail::isPresent(Val))
+    return CastInfo<X, const Y>::castFailed();
+  assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!");
+  return cast<X>(detail::unwrapValue(Val));
+}
+
+template <class X, class Y> [[nodiscard]] inline auto cast_if_present(Y &Val) {
+  if (!detail::isPresent(Val))
+    return CastInfo<X, Y>::castFailed();
+  assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!");
+  return cast<X>(detail::unwrapValue(Val));
+}
+
+template <class X, class Y> [[nodiscard]] inline auto cast_if_present(Y *Val) {
+  if (!detail::isPresent(Val))
+    return CastInfo<X, Y *>::castFailed();
+  assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!");
+  return cast<X>(detail::unwrapValue(Val));
 }
 
 template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
-dyn_cast_or_null(Y *Val) {
-  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
+[[nodiscard]] inline auto cast_if_present(std::unique_ptr<Y> &&Val) {
+  if (!detail::isPresent(Val))
+    return UniquePtrCast<X, Y>::castFailed();
+  return UniquePtrCast<X, Y>::doCast(std::move(Val));
+}
+
+// Provide a forwarding from cast_or_null to cast_if_present for current
+// users. This is deprecated and will be removed in a future patch, use
+// cast_if_present instead.
+template <class X, class Y> auto cast_or_null(const Y &Val) {
+  return cast_if_present<X>(Val);
+}
+
+template <class X, class Y> auto cast_or_null(Y &Val) {
+  return cast_if_present<X>(Val);
+}
+
+template <class X, class Y> auto cast_or_null(Y *Val) {
+  return cast_if_present<X>(Val);
 }
 
-// unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>,
-// taking ownership of the input pointer iff isa<X>(Val) is true.  If the
-// cast is successful, From refers to nullptr on exit and the casted value
-// is returned.  If the cast is unsuccessful, the function returns nullptr
-// and From is unchanged.
+template <class X, class Y> auto cast_or_null(std::unique_ptr<Y> &&Val) {
+  return cast_if_present<X>(std::move(Val));
+}
+
+/// dyn_cast_if_present<X> - Functionally identical to dyn_cast, except that a
+/// null (or none in the case of optionals) value is accepted.
+template <class X, class Y> auto dyn_cast_if_present(const Y &Val) {
+  if (!detail::isPresent(Val))
+    return CastInfo<X, const Y>::castFailed();
+  return CastInfo<X, const Y>::doCastIfPossible(detail::unwrapValue(Val));
+}
+
+template <class X, class Y> auto dyn_cast_if_present(Y &Val) {
+  if (!detail::isPresent(Val))
+    return CastInfo<X, Y>::castFailed();
+  return CastInfo<X, Y>::doCastIfPossible(detail::unwrapValue(Val));
+}
+
+template <class X, class Y> auto dyn_cast_if_present(Y *Val) {
+  if (!detail::isPresent(Val))
+    return CastInfo<X, Y *>::castFailed();
+  return CastInfo<X, Y *>::doCastIfPossible(detail::unwrapValue(Val));
+}
+
+// Forwards to dyn_cast_if_present to avoid breaking current users. This is
+// deprecated and will be removed in a future patch, use
+// cast_if_present instead.
+template <class X, class Y> auto dyn_cast_or_null(const Y &Val) {
+  return dyn_cast_if_present<X>(Val);
+}
+
+template <class X, class Y> auto dyn_cast_or_null(Y &Val) {
+  return dyn_cast_if_present<X>(Val);
+}
+
+template <class X, class Y> auto dyn_cast_or_null(Y *Val) {
+  return dyn_cast_if_present<X>(Val);
+}
+
+/// unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>,
+/// taking ownership of the input pointer iff isa<X>(Val) is true.  If the
+/// cast is successful, From refers to nullptr on exit and the casted value
+/// is returned.  If the cast is unsuccessful, the function returns nullptr
+/// and From is unchanged.
 template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast(std::unique_ptr<Y> &Val)
-    -> decltype(cast<X>(Val)) {
+[[nodiscard]] inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType
+unique_dyn_cast(std::unique_ptr<Y> &Val) {
   if (!isa<X>(Val))
     return nullptr;
   return cast<X>(std::move(Val));
 }
 
 template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val) {
+[[nodiscard]] inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val) {
   return unique_dyn_cast<X, Y>(Val);
 }
 
-// dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast, except that
-// a null value is accepted.
+// unique_dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast,
+// except that a null value is accepted.
 template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &Val)
-    -> decltype(cast<X>(Val)) {
+[[nodiscard]] inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType
+unique_dyn_cast_or_null(std::unique_ptr<Y> &Val) {
   if (!Val)
     return nullptr;
   return unique_dyn_cast<X, Y>(Val);
 }
 
 template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val) {
+[[nodiscard]] inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val) {
   return unique_dyn_cast_or_null<X, Y>(Val);
 }
 
+//===----------------------------------------------------------------------===//
+// Isa Predicates
+//===----------------------------------------------------------------------===//
+
+/// These are wrappers over isa* function that allow them to be used in generic
+/// algorithms such as `llvm:all_of`, `llvm::none_of`, etc. This is accomplished
+/// by exposing the isa* functions through function objects with a generic
+/// function call operator.
+
+namespace detail {
+template <typename... Types> struct IsaCheckPredicate {
+  template <typename T> [[nodiscard]] bool operator()(const T &Val) const {
+    return isa<Types...>(Val);
+  }
+};
+
+template <typename... Types> struct IsaAndPresentCheckPredicate {
+  template <typename T> [[nodiscard]] bool operator()(const T &Val) const {
+    return isa_and_present<Types...>(Val);
+  }
+};
+} // namespace detail
+
+/// Function object wrapper for the `llvm::isa` type check. The function call
+/// operator returns true when the value can be cast to any type in `Types`.
+/// Example:
+/// ```
+/// SmallVector<Type> myTypes = ...;
+/// if (llvm::all_of(myTypes, llvm::IsaPred<VectorType>))
+///   ...
+/// ```
+template <typename... Types>
+inline constexpr detail::IsaCheckPredicate<Types...> IsaPred{};
+
+/// Function object wrapper for the `llvm::isa_and_present` type check. The
+/// function call operator returns true when the value can be cast to any type
+/// in `Types`, or if the value is not present (e.g., nullptr). Example:
+/// ```
+/// SmallVector<Type> myTypes = ...;
+/// if (llvm::all_of(myTypes, llvm::IsaAndPresentPred<VectorType>))
+///   ...
+/// ```
+template <typename... Types>
+inline constexpr detail::IsaAndPresentCheckPredicate<Types...>
+    IsaAndPresentPred{};
+
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_CASTING_H
diff --git a/symbolic-demangle/vendor/swift/include/llvm/Support/Compiler.h b/symbolic-demangle/vendor/swift/include/llvm/Support/Compiler.h
index 57052b596..d8e3794ba 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/Support/Compiler.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/Support/Compiler.h
@@ -17,9 +17,6 @@
 
 #include "llvm/Config/llvm-config.h"
 
-#ifdef __cplusplus
-#include <new>
-#endif
 #include <stddef.h>
 
 #if defined(_MSC_VER)
@@ -42,6 +39,10 @@
 # define __has_builtin(x) 0
 #endif
 
+#ifndef __has_include
+# define __has_include(x) 0
+#endif
+
 // Only use __has_cpp_attribute in C++ mode. GCC defines __has_cpp_attribute in
 // C mode, but the :: in __has_cpp_attribute(scoped::attribute) is invalid.
 #ifndef LLVM_HAS_CPP_ATTRIBUTE
@@ -80,38 +81,27 @@
 /// * 1916: VS2017, version 15.9
 /// * 1920: VS2019, version 16.0
 /// * 1921: VS2019, version 16.1
+/// * 1922: VS2019, version 16.2
+/// * 1923: VS2019, version 16.3
+/// * 1924: VS2019, version 16.4
+/// * 1925: VS2019, version 16.5
+/// * 1926: VS2019, version 16.6
+/// * 1927: VS2019, version 16.7
+/// * 1928: VS2019, version 16.8 + 16.9
+/// * 1929: VS2019, version 16.10 + 16.11
+/// * 1930: VS2022, version 17.0
 #ifdef _MSC_VER
 #define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version))
 
-// We require at least MSVC 2017.
-#if !LLVM_MSC_PREREQ(1910)
-#error LLVM requires at least MSVC 2017.
+// We require at least VS 2019.
+#if !defined(LLVM_FORCE_USE_OLD_TOOLCHAIN)
+#if !LLVM_MSC_PREREQ(1920)
+#error LLVM requires at least VS 2019.
 #endif
-
-#else
-#define LLVM_MSC_PREREQ(version) 0
 #endif
 
-/// Does the compiler support ref-qualifiers for *this?
-///
-/// Sadly, this is separate from just rvalue reference support because GCC
-/// and MSVC implemented this later than everything else. This appears to be
-/// corrected in MSVC 2019 but not MSVC 2017.
-#if __has_feature(cxx_rvalue_references) || LLVM_GNUC_PREREQ(4, 8, 1) ||       \
-    LLVM_MSC_PREREQ(1920)
-#define LLVM_HAS_RVALUE_REFERENCE_THIS 1
 #else
-#define LLVM_HAS_RVALUE_REFERENCE_THIS 0
-#endif
-
-/// Expands to '&' if ref-qualifiers for *this are supported.
-///
-/// This can be used to provide lvalue/rvalue overrides of member functions.
-/// The rvalue override should be guarded by LLVM_HAS_RVALUE_REFERENCE_THIS
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-#define LLVM_LVALUE_FUNCTION &
-#else
-#define LLVM_LVALUE_FUNCTION
+#define LLVM_MSC_PREREQ(version) 0
 #endif
 
 /// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked
@@ -123,10 +113,27 @@
 /// LLVM_EXTERNAL_VISIBILITY - classes, functions, and variables marked with
 /// this attribute will be made public and visible outside of any shared library
 /// they are linked in to.
-#if (__has_attribute(visibility) || LLVM_GNUC_PREREQ(4, 0, 0)) &&              \
-    !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(_WIN32)
-#define LLVM_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))
-#define LLVM_EXTERNAL_VISIBILITY __attribute__ ((visibility("default")))
+
+#if LLVM_HAS_CPP_ATTRIBUTE(gnu::visibility)
+#define LLVM_ATTRIBUTE_VISIBILITY_HIDDEN [[gnu::visibility("hidden")]]
+#define LLVM_ATTRIBUTE_VISIBILITY_DEFAULT [[gnu::visibility("default")]]
+#elif __has_attribute(visibility)
+#define LLVM_ATTRIBUTE_VISIBILITY_HIDDEN __attribute__((visibility("hidden")))
+#define LLVM_ATTRIBUTE_VISIBILITY_DEFAULT __attribute__((visibility("default")))
+#else
+#define LLVM_ATTRIBUTE_VISIBILITY_HIDDEN
+#define LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
+#endif
+
+
+#if (!(defined(_WIN32) || defined(__CYGWIN__)) ||                              \
+     (defined(__MINGW32__) && defined(__clang__)))
+#define LLVM_LIBRARY_VISIBILITY LLVM_ATTRIBUTE_VISIBILITY_HIDDEN
+#if defined(LLVM_BUILD_LLVM_DYLIB) || defined(LLVM_BUILD_SHARED_LIBS)
+#define LLVM_EXTERNAL_VISIBILITY LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
+#else
+#define LLVM_EXTERNAL_VISIBILITY
+#endif
 #else
 #define LLVM_LIBRARY_VISIBILITY
 #define LLVM_EXTERNAL_VISIBILITY
@@ -138,28 +145,36 @@
 #define LLVM_PREFETCH(addr, rw, locality)
 #endif
 
-#if __has_attribute(used) || LLVM_GNUC_PREREQ(3, 1, 0)
+#if __has_attribute(used)
 #define LLVM_ATTRIBUTE_USED __attribute__((__used__))
 #else
 #define LLVM_ATTRIBUTE_USED
 #endif
 
-/// LLVM_NODISCARD - Warn if a type or return value is discarded.
+#if defined(__clang__)
+#define LLVM_DEPRECATED(MSG, FIX) __attribute__((deprecated(MSG, FIX)))
+#else
+#define LLVM_DEPRECATED(MSG, FIX) [[deprecated(MSG)]]
+#endif
 
-// Use the 'nodiscard' attribute in C++17 or newer mode.
-#if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
-#define LLVM_NODISCARD [[nodiscard]]
-#elif LLVM_HAS_CPP_ATTRIBUTE(clang::warn_unused_result)
-#define LLVM_NODISCARD [[clang::warn_unused_result]]
-// Clang in C++14 mode claims that it has the 'nodiscard' attribute, but also
-// warns in the pedantic mode that 'nodiscard' is a C++17 extension (PR33518).
-// Use the 'nodiscard' attribute in C++14 mode only with GCC.
-// TODO: remove this workaround when PR33518 is resolved.
-#elif defined(__GNUC__) && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
-#define LLVM_NODISCARD [[nodiscard]]
+// clang-format off
+#if defined(__clang__) || defined(__GNUC__)
+#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH                             \
+  _Pragma("GCC diagnostic push")                                               \
+  _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_POP                              \
+  _Pragma("GCC diagnostic pop")
+#elif defined(_MSC_VER)
+#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH                             \
+  _Pragma("warning(push)")                                                     \
+  _Pragma("warning(disable : 4996)")
+#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_POP                              \
+  _Pragma("warning(pop)")
 #else
-#define LLVM_NODISCARD
+#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH
+#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_POP
 #endif
+// clang-format on
 
 // Indicate that a non-static, non-const C++ member function reinitializes
 // the entire object to a known state, independent of the previous state of
@@ -182,15 +197,15 @@
 // more portable solution:
 //   (void)unused_var_name;
 // Prefer cast-to-void wherever it is sufficient.
-#if __has_attribute(unused) || LLVM_GNUC_PREREQ(3, 1, 0)
+#if __has_attribute(unused)
 #define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__))
 #else
 #define LLVM_ATTRIBUTE_UNUSED
 #endif
 
 // FIXME: Provide this for PE/COFF targets.
-#if (__has_attribute(weak) || LLVM_GNUC_PREREQ(4, 0, 0)) &&                    \
-    (!defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(_WIN32))
+#if __has_attribute(weak) && !defined(__MINGW32__) && !defined(__CYGWIN__) &&  \
+    !defined(_WIN32)
 #define LLVM_ATTRIBUTE_WEAK __attribute__((__weak__))
 #else
 #define LLVM_ATTRIBUTE_WEAK
@@ -212,7 +227,13 @@
 #define LLVM_READONLY
 #endif
 
-#if __has_builtin(__builtin_expect) || LLVM_GNUC_PREREQ(4, 0, 0)
+#if __has_attribute(minsize)
+#define LLVM_ATTRIBUTE_MINSIZE __attribute__((minsize))
+#else
+#define LLVM_ATTRIBUTE_MINSIZE
+#endif
+
+#if __has_builtin(__builtin_expect) || defined(__GNUC__)
 #define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
 #define LLVM_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
 #else
@@ -222,7 +243,7 @@
 
 /// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
 /// mark a method "not for inlining".
-#if __has_attribute(noinline) || LLVM_GNUC_PREREQ(3, 4, 0)
+#if __has_attribute(noinline)
 #define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline))
 #elif defined(_MSC_VER)
 #define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline)
@@ -231,10 +252,8 @@
 #endif
 
 /// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
-/// so, mark a method "always inline" because it is performance sensitive. GCC
-/// 3.4 supported this but is buggy in various cases and produces unimplemented
-/// errors, just use it in GCC 4.0 and later.
-#if __has_attribute(always_inline) || LLVM_GNUC_PREREQ(4, 0, 0)
+/// so, mark a method "always inline" because it is performance sensitive.
+#if __has_attribute(always_inline)
 #define LLVM_ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline))
 #elif defined(_MSC_VER)
 #define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline
@@ -242,15 +261,16 @@
 #define LLVM_ATTRIBUTE_ALWAYS_INLINE inline
 #endif
 
-#ifdef __GNUC__
-#define LLVM_ATTRIBUTE_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_NORETURN __declspec(noreturn)
+/// LLVM_ATTRIBUTE_NO_DEBUG - On compilers where we have a directive to do
+/// so, mark a method "no debug" because debug info makes the debugger
+/// experience worse.
+#if __has_attribute(nodebug)
+#define LLVM_ATTRIBUTE_NODEBUG __attribute__((nodebug))
 #else
-#define LLVM_ATTRIBUTE_NORETURN
+#define LLVM_ATTRIBUTE_NODEBUG
 #endif
 
-#if __has_attribute(returns_nonnull) || LLVM_GNUC_PREREQ(4, 9, 0)
+#if __has_attribute(returns_nonnull)
 #define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
 #elif defined(_MSC_VER)
 #define LLVM_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_
@@ -258,6 +278,14 @@
 #define LLVM_ATTRIBUTE_RETURNS_NONNULL
 #endif
 
+/// LLVM_ATTRIBUTE_RESTRICT - Annotates a pointer to tell the compiler that
+/// it is not aliased in the current scope.
+#if defined(__clang__) || defined(__GNUC__) || defined(_MSC_VER)
+#define LLVM_ATTRIBUTE_RESTRICT __restrict
+#else
+#define LLVM_ATTRIBUTE_RESTRICT
+#endif
+
 /// \macro LLVM_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a
 /// pointer that does not alias any other valid pointer.
 #ifdef __GNUC__
@@ -306,6 +334,12 @@
 #define LLVM_GSL_POINTER
 #endif
 
+#if LLVM_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L
+#define LLVM_CTOR_NODISCARD [[nodiscard]]
+#else
+#define LLVM_CTOR_NODISCARD
+#endif
+
 /// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
 /// pedantic diagnostics.
 #ifdef __GNUC__
@@ -314,15 +348,14 @@
 #define LLVM_EXTENSION
 #endif
 
-// LLVM_ATTRIBUTE_DEPRECATED(decl, "message")
-// This macro will be removed.
-// Use C++14's attribute instead: [[deprecated("message")]]
-#define LLVM_ATTRIBUTE_DEPRECATED(decl, message) [[deprecated(message)]] decl
-
 /// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
 /// to an expression which states that it is undefined behavior for the
 /// compiler to reach this point.  Otherwise is not defined.
-#if __has_builtin(__builtin_unreachable) || LLVM_GNUC_PREREQ(4, 5, 0)
+///
+/// '#else' is intentionally left out so that other macro logic (e.g.,
+/// LLVM_ASSUME_ALIGNED and llvm_unreachable()) can detect whether
+/// LLVM_BUILTIN_UNREACHABLE has a definition.
+#if __has_builtin(__builtin_unreachable) || defined(__GNUC__)
 # define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
 #elif defined(_MSC_VER)
 # define LLVM_BUILTIN_UNREACHABLE __assume(false)
@@ -330,7 +363,7 @@
 
 /// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression
 /// which causes the program to exit abnormally.
-#if __has_builtin(__builtin_trap) || LLVM_GNUC_PREREQ(4, 3, 0)
+#if __has_builtin(__builtin_trap) || defined(__GNUC__)
 # define LLVM_BUILTIN_TRAP __builtin_trap()
 #elif defined(_MSC_VER)
 // The __debugbreak intrinsic is supported by MSVC, does not require forward
@@ -361,7 +394,7 @@
 
 /// \macro LLVM_ASSUME_ALIGNED
 /// Returns a pointer with an assumed alignment.
-#if __has_builtin(__builtin_assume_aligned) || LLVM_GNUC_PREREQ(4, 7, 0)
+#if __has_builtin(__builtin_assume_aligned) || defined(__GNUC__)
 # define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a)
 #elif defined(LLVM_BUILTIN_UNREACHABLE)
 # define LLVM_ASSUME_ALIGNED(p, a) \
@@ -398,22 +431,6 @@
 # define LLVM_PACKED_END   _Pragma("pack(pop)")
 #endif
 
-/// \macro LLVM_PTR_SIZE
-/// A constant integer equivalent to the value of sizeof(void*).
-/// Generally used in combination with alignas or when doing computation in the
-/// preprocessor.
-#ifdef __SIZEOF_POINTER__
-# define LLVM_PTR_SIZE __SIZEOF_POINTER__
-#elif defined(_WIN64)
-# define LLVM_PTR_SIZE 8
-#elif defined(_WIN32)
-# define LLVM_PTR_SIZE 4
-#elif defined(_MSC_VER)
-# error "could not determine LLVM_PTR_SIZE as a constant int for MSVC"
-#else
-# define LLVM_PTR_SIZE sizeof(void *)
-#endif
-
 /// \macro LLVM_MEMORY_SANITIZER_BUILD
 /// Whether LLVM itself is built with MemorySanitizer instrumentation.
 #if __has_feature(memory_sanitizer)
@@ -431,13 +448,34 @@
 /// Whether LLVM itself is built with AddressSanitizer instrumentation.
 #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
 # define LLVM_ADDRESS_SANITIZER_BUILD 1
+#if __has_include(<sanitizer/asan_interface.h>)
 # include <sanitizer/asan_interface.h>
 #else
+// These declarations exist to support ASan with MSVC. If MSVC eventually ships
+// asan_interface.h in their headers, then we can remove this.
+#ifdef __cplusplus
+extern "C" {
+#endif
+void __asan_poison_memory_region(void const volatile *addr, size_t size);
+void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
+#ifdef __cplusplus
+} // extern "C"
+#endif
+#endif
+#else
 # define LLVM_ADDRESS_SANITIZER_BUILD 0
 # define __asan_poison_memory_region(p, size)
 # define __asan_unpoison_memory_region(p, size)
 #endif
 
+/// \macro LLVM_HWADDRESS_SANITIZER_BUILD
+/// Whether LLVM itself is built with HWAddressSanitizer instrumentation.
+#if __has_feature(hwaddress_sanitizer)
+#define LLVM_HWADDRESS_SANITIZER_BUILD 1
+#else
+#define LLVM_HWADDRESS_SANITIZER_BUILD 0
+#endif
+
 /// \macro LLVM_THREAD_SANITIZER_BUILD
 /// Whether LLVM itself is built with ThreadSanitizer instrumentation.
 #if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__)
@@ -549,4 +587,21 @@ void AnnotateIgnoreWritesEnd(const char *file, int line);
 #define LLVM_ENABLE_EXCEPTIONS 1
 #endif
 
+/// \macro LLVM_NO_PROFILE_INSTRUMENT_FUNCTION
+/// Disable the profile instrument for a function.
+#if __has_attribute(no_profile_instrument_function)
+#define LLVM_NO_PROFILE_INSTRUMENT_FUNCTION                                    \
+  __attribute__((no_profile_instrument_function))
+#else
+#define LLVM_NO_PROFILE_INSTRUMENT_FUNCTION
+#endif
+
+/// \macro LLVM_PREFERRED_TYPE
+/// Adjust type of bit-field in debug info.
+#if __has_attribute(preferred_type)
+#define LLVM_PREFERRED_TYPE(T) __attribute__((preferred_type(T)))
+#else
+#define LLVM_PREFERRED_TYPE(T)
+#endif
+
 #endif
diff --git a/symbolic-demangle/vendor/swift/include/llvm/Support/ErrorHandling.h b/symbolic-demangle/vendor/swift/include/llvm/Support/ErrorHandling.h
index 0ec0242d5..9c8e3448f 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/Support/ErrorHandling.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/Support/ErrorHandling.h
@@ -15,15 +15,14 @@
 #define LLVM_SUPPORT_ERRORHANDLING_H
 
 #include "llvm/Support/Compiler.h"
-#include <string>
 
 namespace llvm {
-class StringRef;
+  class StringRef;
   class Twine;
 
   /// An error handler callback.
   typedef void (*fatal_error_handler_t)(void *user_data,
-                                        const std::string& reason,
+                                        const char *reason,
                                         bool gen_crash_diag);
 
   /// install_fatal_error_handler - Installs a new error handler to be used
@@ -68,14 +67,13 @@ class StringRef;
 /// standard error, followed by a newline.
 /// After the error handler is called this function will call abort(), it
 /// does not return.
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason,
-                                                bool gen_crash_diag = true);
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const std::string &reason,
-                                                bool gen_crash_diag = true);
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(StringRef reason,
-                                                bool gen_crash_diag = true);
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const Twine &reason,
-                                                bool gen_crash_diag = true);
+/// NOTE: The std::string variant was removed to avoid a <string> dependency.
+[[noreturn]] void report_fatal_error(const char *reason,
+                                     bool gen_crash_diag = true);
+[[noreturn]] void report_fatal_error(StringRef reason,
+                                     bool gen_crash_diag = true);
+[[noreturn]] void report_fatal_error(const Twine &reason,
+                                     bool gen_crash_diag = true);
 
 /// Installs a new bad alloc error handler that should be used whenever a
 /// bad alloc error, e.g. failing malloc/calloc, is encountered by LLVM.
@@ -113,32 +111,47 @@ void install_out_of_memory_new_handler();
 /// If no error handler is installed (default), throws a bad_alloc exception
 /// if LLVM is compiled with exception support. Otherwise prints the error
 /// to standard error and calls abort().
-LLVM_ATTRIBUTE_NORETURN void report_bad_alloc_error(const char *Reason,
-                                                    bool GenCrashDiag = true);
+[[noreturn]] void report_bad_alloc_error(const char *Reason,
+                                         bool GenCrashDiag = true);
 
 /// This function calls abort(), and prints the optional message to stderr.
 /// Use the llvm_unreachable macro (that adds location info), instead of
 /// calling this function directly.
-LLVM_ATTRIBUTE_NORETURN void
+[[noreturn]] void
 llvm_unreachable_internal(const char *msg = nullptr, const char *file = nullptr,
                           unsigned line = 0);
 }
 
 /// Marks that the current location is not supposed to be reachable.
 /// In !NDEBUG builds, prints the message and location info to stderr.
-/// In NDEBUG builds, becomes an optimizer hint that the current location
-/// is not supposed to be reachable.  On compilers that don't support
-/// such hints, prints a reduced message instead and aborts the program.
+/// In NDEBUG builds, if the platform does not support a builtin unreachable
+/// then we call an internal LLVM runtime function. Otherwise the behavior is
+/// controlled by the CMake flag
+///   -DLLVM_UNREACHABLE_OPTIMIZE
+/// * When "ON" (default) llvm_unreachable() becomes an optimizer hint
+///   that the current location is not supposed to be reachable: the hint
+///   turns such code path into undefined behavior.  On compilers that don't
+///   support such hints, prints a reduced message instead and aborts the
+///   program.
+/// * When "OFF", a builtin_trap is emitted instead of an
+//    optimizer hint or printing a reduced message.
 ///
-/// Use this instead of assert(0).  It conveys intent more clearly and
-/// allows compilers to omit some unnecessary code.
+/// Use this instead of assert(0). It conveys intent more clearly, suppresses
+/// diagnostics for unreachable code paths, and allows compilers to omit
+/// unnecessary code.
 #ifndef NDEBUG
 #define llvm_unreachable(msg) \
   ::llvm::llvm_unreachable_internal(msg, __FILE__, __LINE__)
-#elif defined(LLVM_BUILTIN_UNREACHABLE)
+#elif !defined(LLVM_BUILTIN_UNREACHABLE)
+#define llvm_unreachable(msg) ::llvm::llvm_unreachable_internal()
+#elif LLVM_UNREACHABLE_OPTIMIZE
 #define llvm_unreachable(msg) LLVM_BUILTIN_UNREACHABLE
 #else
-#define llvm_unreachable(msg) ::llvm::llvm_unreachable_internal()
+#define llvm_unreachable(msg)                                                  \
+  do {                                                                         \
+    LLVM_BUILTIN_TRAP;                                                         \
+    LLVM_BUILTIN_UNREACHABLE;                                                  \
+  } while (false)
 #endif
 
 #endif
diff --git a/symbolic-demangle/vendor/swift/include/llvm/Support/MemAlloc.h b/symbolic-demangle/vendor/swift/include/llvm/Support/MemAlloc.h
deleted file mode 100644
index d6012bd5a..000000000
--- a/symbolic-demangle/vendor/swift/include/llvm/Support/MemAlloc.h
+++ /dev/null
@@ -1,87 +0,0 @@
-//===- MemAlloc.h - Memory allocation functions -----------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-/// \file
-///
-/// This file defines counterparts of C library allocation functions defined in
-/// the namespace 'std'. The new allocation functions crash on allocation
-/// failure instead of returning null pointer.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_MEMALLOC_H
-#define LLVM_SUPPORT_MEMALLOC_H
-
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/ErrorHandling.h"
-#include <cstdlib>
-
-namespace llvm {
-
-LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_malloc(size_t Sz) {
-  void *Result = std::malloc(Sz);
-  if (Result == nullptr) {
-    // It is implementation-defined whether allocation occurs if the space
-    // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting
-    // non-zero, if the space requested was zero.
-    if (Sz == 0)
-      return safe_malloc(1);
-    report_bad_alloc_error("Allocation failed");
-  }
-  return Result;
-}
-
-LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_calloc(size_t Count,
-                                                        size_t Sz) {
-  void *Result = std::calloc(Count, Sz);
-  if (Result == nullptr) {
-    // It is implementation-defined whether allocation occurs if the space
-    // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting
-    // non-zero, if the space requested was zero.
-    if (Count == 0 || Sz == 0)
-      return safe_malloc(1);
-    report_bad_alloc_error("Allocation failed");
-  }
-  return Result;
-}
-
-LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_realloc(void *Ptr, size_t Sz) {
-  void *Result = std::realloc(Ptr, Sz);
-  if (Result == nullptr) {
-    // It is implementation-defined whether allocation occurs if the space
-    // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting
-    // non-zero, if the space requested was zero.
-    if (Sz == 0)
-      return safe_malloc(1);
-    report_bad_alloc_error("Allocation failed");
-  }
-  return Result;
-}
-
-/// Allocate a buffer of memory with the given size and alignment.
-///
-/// When the compiler supports aligned operator new, this will use it to to
-/// handle even over-aligned allocations.
-///
-/// However, this doesn't make any attempt to leverage the fancier techniques
-/// like posix_memalign due to portability. It is mostly intended to allow
-/// compatibility with platforms that, after aligned allocation was added, use
-/// reduced default alignment.
-LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
-allocate_buffer(size_t Size, size_t Alignment);
-
-/// Deallocate a buffer of memory with the given size and alignment.
-///
-/// If supported, this will used the sized delete operator. Also if supported,
-/// this will pass the alignment to the delete operator.
-///
-/// The pointer must have been allocated with the corresponding new operator,
-/// most likely using the above helper.
-void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment);
-
-} // namespace llvm
-#endif
diff --git a/symbolic-demangle/vendor/swift/include/llvm/Support/SwapByteOrder.h b/symbolic-demangle/vendor/swift/include/llvm/Support/SwapByteOrder.h
index e8612ba66..e6d4c2683 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/Support/SwapByteOrder.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/Support/SwapByteOrder.h
@@ -14,144 +14,47 @@
 #ifndef LLVM_SUPPORT_SWAPBYTEORDER_H
 #define LLVM_SUPPORT_SWAPBYTEORDER_H
 
-#include <cstddef>
+#include "llvm/ADT/STLForwardCompat.h"
+#include "llvm/ADT/bit.h"
 #include <cstdint>
 #include <type_traits>
-#if defined(_MSC_VER) && !defined(_DEBUG)
-#include <stdlib.h>
-#endif
-
-#if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) ||            \
-    defined(__Fuchsia__) || defined(__EMSCRIPTEN__)
-#include <endian.h>
-#elif defined(_AIX)
-#include <sys/machine.h>
-#elif defined(__sun)
-/* Solaris provides _BIG_ENDIAN/_LITTLE_ENDIAN selector in sys/types.h */
-#include <sys/types.h>
-#define BIG_ENDIAN 4321
-#define LITTLE_ENDIAN 1234
-#if defined(_BIG_ENDIAN)
-#define BYTE_ORDER BIG_ENDIAN
-#else
-#define BYTE_ORDER LITTLE_ENDIAN
-#endif
-#elif defined(__MVS__)
-#define BIG_ENDIAN 4321
-#define LITTLE_ENDIAN 1234
-#define BYTE_ORDER BIG_ENDIAN
-#else
-#if !defined(BYTE_ORDER) && !defined(_WIN32)
-#include <machine/endian.h>
-#endif
-#endif
 
 namespace llvm {
 
-/// ByteSwap_16 - This function returns a byte-swapped representation of
-/// the 16-bit argument.
-inline uint16_t ByteSwap_16(uint16_t value) {
-#if defined(_MSC_VER) && !defined(_DEBUG)
-  // The DLL version of the runtime lacks these functions (bug!?), but in a
-  // release build they're replaced with BSWAP instructions anyway.
-  return _byteswap_ushort(value);
-#else
-  uint16_t Hi = value << 8;
-  uint16_t Lo = value >> 8;
-  return Hi | Lo;
-#endif
-}
-
-/// This function returns a byte-swapped representation of the 32-bit argument.
-inline uint32_t ByteSwap_32(uint32_t value) {
-#if defined(__llvm__) || (defined(__GNUC__) && !defined(__ICC))
-  return __builtin_bswap32(value);
-#elif defined(_MSC_VER) && !defined(_DEBUG)
-  return _byteswap_ulong(value);
-#else
-  uint32_t Byte0 = value & 0x000000FF;
-  uint32_t Byte1 = value & 0x0000FF00;
-  uint32_t Byte2 = value & 0x00FF0000;
-  uint32_t Byte3 = value & 0xFF000000;
-  return (Byte0 << 24) | (Byte1 << 8) | (Byte2 >> 8) | (Byte3 >> 24);
-#endif
-}
-
-/// This function returns a byte-swapped representation of the 64-bit argument.
-inline uint64_t ByteSwap_64(uint64_t value) {
-#if defined(__llvm__) || (defined(__GNUC__) && !defined(__ICC))
-  return __builtin_bswap64(value);
-#elif defined(_MSC_VER) && !defined(_DEBUG)
-  return _byteswap_uint64(value);
-#else
-  uint64_t Hi = ByteSwap_32(uint32_t(value));
-  uint32_t Lo = ByteSwap_32(uint32_t(value >> 32));
-  return (Hi << 32) | Lo;
-#endif
-}
-
 namespace sys {
 
-#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
-constexpr bool IsBigEndianHost = true;
-#else
-constexpr bool IsBigEndianHost = false;
-#endif
+constexpr bool IsBigEndianHost =
+    llvm::endianness::native == llvm::endianness::big;
 
 static const bool IsLittleEndianHost = !IsBigEndianHost;
 
-inline unsigned char  getSwappedBytes(unsigned char C) { return C; }
-inline   signed char  getSwappedBytes(signed char C) { return C; }
-inline          char  getSwappedBytes(char C) { return C; }
+inline unsigned char      getSwappedBytes(unsigned char      C) { return llvm::byteswap(C); }
+inline   signed char      getSwappedBytes( signed  char      C) { return llvm::byteswap(C); }
+inline          char      getSwappedBytes(         char      C) { return llvm::byteswap(C); }
 
-inline unsigned short getSwappedBytes(unsigned short C) { return ByteSwap_16(C); }
-inline   signed short getSwappedBytes(  signed short C) { return ByteSwap_16(C); }
+inline unsigned short     getSwappedBytes(unsigned short     C) { return llvm::byteswap(C); }
+inline   signed short     getSwappedBytes(  signed short     C) { return llvm::byteswap(C); }
 
-inline unsigned int   getSwappedBytes(unsigned int   C) { return ByteSwap_32(C); }
-inline   signed int   getSwappedBytes(  signed int   C) { return ByteSwap_32(C); }
+inline unsigned int       getSwappedBytes(unsigned int       C) { return llvm::byteswap(C); }
+inline   signed int       getSwappedBytes(  signed int       C) { return llvm::byteswap(C); }
 
-inline unsigned long getSwappedBytes(unsigned long C) {
-  // Handle LLP64 and LP64 platforms.
-  return sizeof(long) == sizeof(int) ? ByteSwap_32((uint32_t)C)
-                                     : ByteSwap_64((uint64_t)C);
-}
-inline signed long getSwappedBytes(signed long C) {
-  // Handle LLP64 and LP64 platforms.
-  return sizeof(long) == sizeof(int) ? ByteSwap_32((uint32_t)C)
-                                     : ByteSwap_64((uint64_t)C);
-}
+inline unsigned long      getSwappedBytes(unsigned long      C) { return llvm::byteswap(C); }
+inline   signed long      getSwappedBytes(  signed long      C) { return llvm::byteswap(C); }
 
-inline unsigned long long getSwappedBytes(unsigned long long C) {
-  return ByteSwap_64(C);
-}
-inline signed long long getSwappedBytes(signed long long C) {
-  return ByteSwap_64(C);
-}
+inline unsigned long long getSwappedBytes(unsigned long long C) { return llvm::byteswap(C); }
+inline   signed long long getSwappedBytes(  signed long long C) { return llvm::byteswap(C); }
 
 inline float getSwappedBytes(float C) {
-  union {
-    uint32_t i;
-    float f;
-  } in, out;
-  in.f = C;
-  out.i = ByteSwap_32(in.i);
-  return out.f;
+  return llvm::bit_cast<float>(llvm::byteswap(llvm::bit_cast<uint32_t>(C)));
 }
 
 inline double getSwappedBytes(double C) {
-  union {
-    uint64_t i;
-    double d;
-  } in, out;
-  in.d = C;
-  out.i = ByteSwap_64(in.i);
-  return out.d;
+  return llvm::bit_cast<double>(llvm::byteswap(llvm::bit_cast<uint64_t>(C)));
 }
 
 template <typename T>
-inline std::enable_if_t<std::is_enum<T>::value, T> getSwappedBytes(T C) {
-  return static_cast<T>(
-      getSwappedBytes(static_cast<std::underlying_type_t<T>>(C)));
+inline std::enable_if_t<std::is_enum_v<T>, T> getSwappedBytes(T C) {
+  return static_cast<T>(llvm::byteswap(llvm::to_underlying(C)));
 }
 
 template<typename T>
diff --git a/symbolic-demangle/vendor/swift/include/llvm/Support/raw_ostream.h b/symbolic-demangle/vendor/swift/include/llvm/Support/raw_ostream.h
deleted file mode 100644
index c669c2bab..000000000
--- a/symbolic-demangle/vendor/swift/include/llvm/Support/raw_ostream.h
+++ /dev/null
@@ -1,739 +0,0 @@
-//===--- raw_ostream.h - Raw output stream ----------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file defines the raw_ostream class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_RAW_OSTREAM_H
-#define LLVM_SUPPORT_RAW_OSTREAM_H
-
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/DataTypes.h"
-#include <cassert>
-#include <chrono>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <string>
-#if __cplusplus > 201402L
-#include <string_view>
-#endif
-#include <system_error>
-#include <type_traits>
-
-namespace llvm {
-
-class formatv_object_base;
-class format_object_base;
-class FormattedString;
-class FormattedNumber;
-class FormattedBytes;
-template <class T> class LLVM_NODISCARD Expected;
-
-namespace sys {
-namespace fs {
-enum FileAccess : unsigned;
-enum OpenFlags : unsigned;
-enum CreationDisposition : unsigned;
-class FileLocker;
-} // end namespace fs
-} // end namespace sys
-
-/// This class implements an extremely fast bulk output stream that can *only*
-/// output to a stream.  It does not support seeking, reopening, rewinding, line
-/// buffered disciplines etc. It is a simple buffer that outputs
-/// a chunk at a time.
-class raw_ostream {
-public:
-  // Class kinds to support LLVM-style RTTI.
-  enum class OStreamKind {
-    OK_OStream,
-    OK_FDStream,
-  };
-
-private:
-  OStreamKind Kind;
-
-  /// The buffer is handled in such a way that the buffer is
-  /// uninitialized, unbuffered, or out of space when OutBufCur >=
-  /// OutBufEnd. Thus a single comparison suffices to determine if we
-  /// need to take the slow path to write a single character.
-  ///
-  /// The buffer is in one of three states:
-  ///  1. Unbuffered (BufferMode == Unbuffered)
-  ///  1. Uninitialized (BufferMode != Unbuffered && OutBufStart == 0).
-  ///  2. Buffered (BufferMode != Unbuffered && OutBufStart != 0 &&
-  ///               OutBufEnd - OutBufStart >= 1).
-  ///
-  /// If buffered, then the raw_ostream owns the buffer if (BufferMode ==
-  /// InternalBuffer); otherwise the buffer has been set via SetBuffer and is
-  /// managed by the subclass.
-  ///
-  /// If a subclass installs an external buffer using SetBuffer then it can wait
-  /// for a \see write_impl() call to handle the data which has been put into
-  /// this buffer.
-  char *OutBufStart, *OutBufEnd, *OutBufCur;
-  bool ColorEnabled = false;
-
-  /// Optional stream this stream is tied to. If this stream is written to, the
-  /// tied-to stream will be flushed first.
-  raw_ostream *TiedStream = nullptr;
-
-  enum class BufferKind {
-    Unbuffered = 0,
-    InternalBuffer,
-    ExternalBuffer
-  } BufferMode;
-
-public:
-  // color order matches ANSI escape sequence, don't change
-  enum class Colors {
-    BLACK = 0,
-    RED,
-    GREEN,
-    YELLOW,
-    BLUE,
-    MAGENTA,
-    CYAN,
-    WHITE,
-    SAVEDCOLOR,
-    RESET,
-  };
-
-  static constexpr Colors BLACK = Colors::BLACK;
-  static constexpr Colors RED = Colors::RED;
-  static constexpr Colors GREEN = Colors::GREEN;
-  static constexpr Colors YELLOW = Colors::YELLOW;
-  static constexpr Colors BLUE = Colors::BLUE;
-  static constexpr Colors MAGENTA = Colors::MAGENTA;
-  static constexpr Colors CYAN = Colors::CYAN;
-  static constexpr Colors WHITE = Colors::WHITE;
-  static constexpr Colors SAVEDCOLOR = Colors::SAVEDCOLOR;
-  static constexpr Colors RESET = Colors::RESET;
-
-  explicit raw_ostream(bool unbuffered = false,
-                       OStreamKind K = OStreamKind::OK_OStream)
-      : Kind(K), BufferMode(unbuffered ? BufferKind::Unbuffered
-                                       : BufferKind::InternalBuffer) {
-    // Start out ready to flush.
-    OutBufStart = OutBufEnd = OutBufCur = nullptr;
-  }
-
-  raw_ostream(const raw_ostream &) = delete;
-  void operator=(const raw_ostream &) = delete;
-
-  virtual ~raw_ostream();
-
-  /// tell - Return the current offset with the file.
-  uint64_t tell() const { return current_pos() + GetNumBytesInBuffer(); }
-
-  OStreamKind get_kind() const { return Kind; }
-
-  //===--------------------------------------------------------------------===//
-  // Configuration Interface
-  //===--------------------------------------------------------------------===//
-
-  /// If possible, pre-allocate \p ExtraSize bytes for stream data.
-  /// i.e. it extends internal buffers to keep additional ExtraSize bytes.
-  /// So that the stream could keep at least tell() + ExtraSize bytes
-  /// without re-allocations. reserveExtraSpace() does not change
-  /// the size/data of the stream.
-  virtual void reserveExtraSpace(uint64_t ExtraSize) {}
-
-  /// Set the stream to be buffered, with an automatically determined buffer
-  /// size.
-  void SetBuffered();
-
-  /// Set the stream to be buffered, using the specified buffer size.
-  void SetBufferSize(size_t Size) {
-    flush();
-    SetBufferAndMode(new char[Size], Size, BufferKind::InternalBuffer);
-  }
-
-  size_t GetBufferSize() const {
-    // If we're supposed to be buffered but haven't actually gotten around
-    // to allocating the buffer yet, return the value that would be used.
-    if (BufferMode != BufferKind::Unbuffered && OutBufStart == nullptr)
-      return preferred_buffer_size();
-
-    // Otherwise just return the size of the allocated buffer.
-    return OutBufEnd - OutBufStart;
-  }
-
-  /// Set the stream to be unbuffered. When unbuffered, the stream will flush
-  /// after every write. This routine will also flush the buffer immediately
-  /// when the stream is being set to unbuffered.
-  void SetUnbuffered() {
-    flush();
-    SetBufferAndMode(nullptr, 0, BufferKind::Unbuffered);
-  }
-
-  size_t GetNumBytesInBuffer() const {
-    return OutBufCur - OutBufStart;
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Data Output Interface
-  //===--------------------------------------------------------------------===//
-
-  void flush() {
-    if (OutBufCur != OutBufStart)
-      flush_nonempty();
-  }
-
-  raw_ostream &operator<<(char C) {
-    if (OutBufCur >= OutBufEnd)
-      return write(C);
-    *OutBufCur++ = C;
-    return *this;
-  }
-
-  raw_ostream &operator<<(unsigned char C) {
-    if (OutBufCur >= OutBufEnd)
-      return write(C);
-    *OutBufCur++ = C;
-    return *this;
-  }
-
-  raw_ostream &operator<<(signed char C) {
-    if (OutBufCur >= OutBufEnd)
-      return write(C);
-    *OutBufCur++ = C;
-    return *this;
-  }
-
-  raw_ostream &operator<<(StringRef Str) {
-    // Inline fast path, particularly for strings with a known length.
-    size_t Size = Str.size();
-
-    // Make sure we can use the fast path.
-    if (Size > (size_t)(OutBufEnd - OutBufCur))
-      return write(Str.data(), Size);
-
-    if (Size) {
-      memcpy(OutBufCur, Str.data(), Size);
-      OutBufCur += Size;
-    }
-    return *this;
-  }
-
-  raw_ostream &operator<<(const char *Str) {
-    // Inline fast path, particularly for constant strings where a sufficiently
-    // smart compiler will simplify strlen.
-
-    return this->operator<<(StringRef(Str));
-  }
-
-  raw_ostream &operator<<(const std::string &Str) {
-    // Avoid the fast path, it would only increase code size for a marginal win.
-    return write(Str.data(), Str.length());
-  }
-
-#if __cplusplus > 201402L
-  raw_ostream &operator<<(const std::string_view &Str) {
-    return write(Str.data(), Str.length());
-  }
-#endif
-
-  raw_ostream &operator<<(const SmallVectorImpl<char> &Str) {
-    return write(Str.data(), Str.size());
-  }
-
-  raw_ostream &operator<<(unsigned long N);
-  raw_ostream &operator<<(long N);
-  raw_ostream &operator<<(unsigned long long N);
-  raw_ostream &operator<<(long long N);
-  raw_ostream &operator<<(const void *P);
-
-  raw_ostream &operator<<(unsigned int N) {
-    return this->operator<<(static_cast<unsigned long>(N));
-  }
-
-  raw_ostream &operator<<(int N) {
-    return this->operator<<(static_cast<long>(N));
-  }
-
-  raw_ostream &operator<<(double N);
-
-  /// Output \p N in hexadecimal, without any prefix or padding.
-  raw_ostream &write_hex(unsigned long long N);
-
-  // Change the foreground color of text.
-  raw_ostream &operator<<(Colors C);
-
-  /// Output a formatted UUID with dash separators.
-  using uuid_t = uint8_t[16];
-  raw_ostream &write_uuid(const uuid_t UUID);
-
-  /// Output \p Str, turning '\\', '\t', '\n', '"', and anything that doesn't
-  /// satisfy llvm::isPrint into an escape sequence.
-  raw_ostream &write_escaped(StringRef Str, bool UseHexEscapes = false);
-
-  raw_ostream &write(unsigned char C);
-  raw_ostream &write(const char *Ptr, size_t Size);
-
-  // Formatted output, see the format() function in Support/Format.h.
-  raw_ostream &operator<<(const format_object_base &Fmt);
-
-  // Formatted output, see the leftJustify() function in Support/Format.h.
-  raw_ostream &operator<<(const FormattedString &);
-
-  // Formatted output, see the formatHex() function in Support/Format.h.
-  raw_ostream &operator<<(const FormattedNumber &);
-
-  // Formatted output, see the formatv() function in Support/FormatVariadic.h.
-  raw_ostream &operator<<(const formatv_object_base &);
-
-  // Formatted output, see the format_bytes() function in Support/Format.h.
-  raw_ostream &operator<<(const FormattedBytes &);
-
-  /// indent - Insert 'NumSpaces' spaces.
-  raw_ostream &indent(unsigned NumSpaces);
-
-  /// write_zeros - Insert 'NumZeros' nulls.
-  raw_ostream &write_zeros(unsigned NumZeros);
-
-  /// Changes the foreground color of text that will be output from this point
-  /// forward.
-  /// @param Color ANSI color to use, the special SAVEDCOLOR can be used to
-  /// change only the bold attribute, and keep colors untouched
-  /// @param Bold bold/brighter text, default false
-  /// @param BG if true change the background, default: change foreground
-  /// @returns itself so it can be used within << invocations
-  virtual raw_ostream &changeColor(enum Colors Color, bool Bold = false,
-                                   bool BG = false);
-
-  /// Resets the colors to terminal defaults. Call this when you are done
-  /// outputting colored text, or before program exit.
-  virtual raw_ostream &resetColor();
-
-  /// Reverses the foreground and background colors.
-  virtual raw_ostream &reverseColor();
-
-  /// This function determines if this stream is connected to a "tty" or
-  /// "console" window. That is, the output would be displayed to the user
-  /// rather than being put on a pipe or stored in a file.
-  virtual bool is_displayed() const { return false; }
-
-  /// This function determines if this stream is displayed and supports colors.
-  /// The result is unaffected by calls to enable_color().
-  virtual bool has_colors() const { return is_displayed(); }
-
-  // Enable or disable colors. Once enable_colors(false) is called,
-  // changeColor() has no effect until enable_colors(true) is called.
-  virtual void enable_colors(bool enable) { ColorEnabled = enable; }
-
-  /// Tie this stream to the specified stream. Replaces any existing tied-to
-  /// stream. Specifying a nullptr unties the stream.
-  void tie(raw_ostream *TieTo) { TiedStream = TieTo; }
-
-  //===--------------------------------------------------------------------===//
-  // Subclass Interface
-  //===--------------------------------------------------------------------===//
-
-private:
-  /// The is the piece of the class that is implemented by subclasses.  This
-  /// writes the \p Size bytes starting at
-  /// \p Ptr to the underlying stream.
-  ///
-  /// This function is guaranteed to only be called at a point at which it is
-  /// safe for the subclass to install a new buffer via SetBuffer.
-  ///
-  /// \param Ptr The start of the data to be written. For buffered streams this
-  /// is guaranteed to be the start of the buffer.
-  ///
-  /// \param Size The number of bytes to be written.
-  ///
-  /// \invariant { Size > 0 }
-  virtual void write_impl(const char *Ptr, size_t Size) = 0;
-
-  /// Return the current position within the stream, not counting the bytes
-  /// currently in the buffer.
-  virtual uint64_t current_pos() const = 0;
-
-protected:
-  /// Use the provided buffer as the raw_ostream buffer. This is intended for
-  /// use only by subclasses which can arrange for the output to go directly
-  /// into the desired output buffer, instead of being copied on each flush.
-  void SetBuffer(char *BufferStart, size_t Size) {
-    SetBufferAndMode(BufferStart, Size, BufferKind::ExternalBuffer);
-  }
-
-  /// Return an efficient buffer size for the underlying output mechanism.
-  virtual size_t preferred_buffer_size() const;
-
-  /// Return the beginning of the current stream buffer, or 0 if the stream is
-  /// unbuffered.
-  const char *getBufferStart() const { return OutBufStart; }
-
-  //===--------------------------------------------------------------------===//
-  // Private Interface
-  //===--------------------------------------------------------------------===//
-private:
-  /// Install the given buffer and mode.
-  void SetBufferAndMode(char *BufferStart, size_t Size, BufferKind Mode);
-
-  /// Flush the current buffer, which is known to be non-empty. This outputs the
-  /// currently buffered data and resets the buffer to empty.
-  void flush_nonempty();
-
-  /// Copy data into the buffer. Size must not be greater than the number of
-  /// unused bytes in the buffer.
-  void copy_to_buffer(const char *Ptr, size_t Size);
-
-  /// Compute whether colors should be used and do the necessary work such as
-  /// flushing. The result is affected by calls to enable_color().
-  bool prepare_colors();
-
-  /// Flush the tied-to stream (if present) and then write the required data.
-  void flush_tied_then_write(const char *Ptr, size_t Size);
-
-  virtual void anchor();
-};
-
-/// Call the appropriate insertion operator, given an rvalue reference to a
-/// raw_ostream object and return a stream of the same type as the argument.
-template <typename OStream, typename T>
-std::enable_if_t<!std::is_reference<OStream>::value &&
-                     std::is_base_of<raw_ostream, OStream>::value,
-                 OStream &&>
-operator<<(OStream &&OS, const T &Value) {
-  OS << Value;
-  return std::move(OS);
-}
-
-/// An abstract base class for streams implementations that also support a
-/// pwrite operation. This is useful for code that can mostly stream out data,
-/// but needs to patch in a header that needs to know the output size.
-class raw_pwrite_stream : public raw_ostream {
-  virtual void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) = 0;
-  void anchor() override;
-
-public:
-  explicit raw_pwrite_stream(bool Unbuffered = false,
-                             OStreamKind K = OStreamKind::OK_OStream)
-      : raw_ostream(Unbuffered, K) {}
-  void pwrite(const char *Ptr, size_t Size, uint64_t Offset) {
-#ifndef NDEBUG
-    uint64_t Pos = tell();
-    // /dev/null always reports a pos of 0, so we cannot perform this check
-    // in that case.
-    if (Pos)
-      assert(Size + Offset <= Pos && "We don't support extending the stream");
-#endif
-    pwrite_impl(Ptr, Size, Offset);
-  }
-};
-
-//===----------------------------------------------------------------------===//
-// File Output Streams
-//===----------------------------------------------------------------------===//
-
-/// A raw_ostream that writes to a file descriptor.
-///
-class raw_fd_ostream : public raw_pwrite_stream {
-  int FD;
-  bool ShouldClose;
-  bool SupportsSeeking = false;
-  mutable Optional<bool> HasColors;
-
-#ifdef _WIN32
-  /// True if this fd refers to a Windows console device. Mintty and other
-  /// terminal emulators are TTYs, but they are not consoles.
-  bool IsWindowsConsole = false;
-#endif
-
-  std::error_code EC;
-
-  uint64_t pos = 0;
-
-  /// See raw_ostream::write_impl.
-  void write_impl(const char *Ptr, size_t Size) override;
-
-  void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
-
-  /// Return the current position within the stream, not counting the bytes
-  /// currently in the buffer.
-  uint64_t current_pos() const override { return pos; }
-
-  /// Determine an efficient buffer size.
-  size_t preferred_buffer_size() const override;
-
-  void anchor() override;
-
-protected:
-  /// Set the flag indicating that an output error has been encountered.
-  void error_detected(std::error_code EC) { this->EC = EC; }
-
-  /// Return the file descriptor.
-  int get_fd() const { return FD; }
-
-  // Update the file position by increasing \p Delta.
-  void inc_pos(uint64_t Delta) { pos += Delta; }
-
-public:
-  /// Open the specified file for writing. If an error occurs, information
-  /// about the error is put into EC, and the stream should be immediately
-  /// destroyed;
-  /// \p Flags allows optional flags to control how the file will be opened.
-  ///
-  /// As a special case, if Filename is "-", then the stream will use
-  /// STDOUT_FILENO instead of opening a file. This will not close the stdout
-  /// descriptor.
-  raw_fd_ostream(StringRef Filename, std::error_code &EC);
-  raw_fd_ostream(StringRef Filename, std::error_code &EC,
-                 sys::fs::CreationDisposition Disp);
-  raw_fd_ostream(StringRef Filename, std::error_code &EC,
-                 sys::fs::FileAccess Access);
-  raw_fd_ostream(StringRef Filename, std::error_code &EC,
-                 sys::fs::OpenFlags Flags);
-  raw_fd_ostream(StringRef Filename, std::error_code &EC,
-                 sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access,
-                 sys::fs::OpenFlags Flags);
-
-  /// FD is the file descriptor that this writes to.  If ShouldClose is true,
-  /// this closes the file when the stream is destroyed. If FD is for stdout or
-  /// stderr, it will not be closed.
-  raw_fd_ostream(int fd, bool shouldClose, bool unbuffered = false,
-                 OStreamKind K = OStreamKind::OK_OStream);
-
-  ~raw_fd_ostream() override;
-
-  /// Manually flush the stream and close the file. Note that this does not call
-  /// fsync.
-  void close();
-
-  bool supportsSeeking() const { return SupportsSeeking; }
-
-  /// Flushes the stream and repositions the underlying file descriptor position
-  /// to the offset specified from the beginning of the file.
-  uint64_t seek(uint64_t off);
-
-  bool is_displayed() const override;
-
-  bool has_colors() const override;
-
-  std::error_code error() const { return EC; }
-
-  /// Return the value of the flag in this raw_fd_ostream indicating whether an
-  /// output error has been encountered.
-  /// This doesn't implicitly flush any pending output.  Also, it doesn't
-  /// guarantee to detect all errors unless the stream has been closed.
-  bool has_error() const { return bool(EC); }
-
-  /// Set the flag read by has_error() to false. If the error flag is set at the
-  /// time when this raw_ostream's destructor is called, report_fatal_error is
-  /// called to report the error. Use clear_error() after handling the error to
-  /// avoid this behavior.
-  ///
-  ///   "Errors should never pass silently.
-  ///    Unless explicitly silenced."
-  ///      - from The Zen of Python, by Tim Peters
-  ///
-  void clear_error() { EC = std::error_code(); }
-
-  /// Locks the underlying file.
-  ///
-  /// @returns RAII object that releases the lock upon leaving the scope, if the
-  ///          locking was successful. Otherwise returns corresponding
-  ///          error code.
-  ///
-  /// The function blocks the current thread until the lock become available or
-  /// error occurs.
-  ///
-  /// Possible use of this function may be as follows:
-  ///
-  ///   @code{.cpp}
-  ///   if (auto L = stream.lock()) {
-  ///     // ... do action that require file to be locked.
-  ///   } else {
-  ///     handleAllErrors(std::move(L.takeError()), [&](ErrorInfoBase &EIB) {
-  ///       // ... handle lock error.
-  ///     });
-  ///   }
-  ///   @endcode
-  LLVM_NODISCARD Expected<sys::fs::FileLocker> lock();
-
-  /// Tries to lock the underlying file within the specified period.
-  ///
-  /// @returns RAII object that releases the lock upon leaving the scope, if the
-  ///          locking was successful. Otherwise returns corresponding
-  ///          error code.
-  ///
-  /// It is used as @ref lock.
-  LLVM_NODISCARD
-  Expected<sys::fs::FileLocker> tryLockFor(std::chrono::milliseconds Timeout);
-};
-
-/// This returns a reference to a raw_fd_ostream for standard output. Use it
-/// like: outs() << "foo" << "bar";
-raw_fd_ostream &outs();
-
-/// This returns a reference to a raw_ostream for standard error.
-/// Use it like: errs() << "foo" << "bar";
-/// By default, the stream is tied to stdout to ensure stdout is flushed before
-/// stderr is written, to ensure the error messages are written in their
-/// expected place.
-raw_fd_ostream &errs();
-
-/// This returns a reference to a raw_ostream which simply discards output.
-raw_ostream &nulls();
-
-//===----------------------------------------------------------------------===//
-// File Streams
-//===----------------------------------------------------------------------===//
-
-/// A raw_ostream of a file for reading/writing/seeking.
-///
-class raw_fd_stream : public raw_fd_ostream {
-public:
-  /// Open the specified file for reading/writing/seeking. If an error occurs,
-  /// information about the error is put into EC, and the stream should be
-  /// immediately destroyed.
-  raw_fd_stream(StringRef Filename, std::error_code &EC);
-
-  /// This reads the \p Size bytes into a buffer pointed by \p Ptr.
-  ///
-  /// \param Ptr The start of the buffer to hold data to be read.
-  ///
-  /// \param Size The number of bytes to be read.
-  ///
-  /// On success, the number of bytes read is returned, and the file position is
-  /// advanced by this number. On error, -1 is returned, use error() to get the
-  /// error code.
-  ssize_t read(char *Ptr, size_t Size);
-
-  /// Check if \p OS is a pointer of type raw_fd_stream*.
-  static bool classof(const raw_ostream *OS);
-};
-
-//===----------------------------------------------------------------------===//
-// Output Stream Adaptors
-//===----------------------------------------------------------------------===//
-
-/// A raw_ostream that writes to an std::string.  This is a simple adaptor
-/// class. This class does not encounter output errors.
-class raw_string_ostream : public raw_ostream {
-  std::string &OS;
-
-  /// See raw_ostream::write_impl.
-  void write_impl(const char *Ptr, size_t Size) override;
-
-  /// Return the current position within the stream, not counting the bytes
-  /// currently in the buffer.
-  uint64_t current_pos() const override { return OS.size(); }
-
-public:
-  explicit raw_string_ostream(std::string &O) : OS(O) {
-    SetUnbuffered();
-  }
-  ~raw_string_ostream() override;
-
-  /// Flushes the stream contents to the target string and returns  the string's
-  /// reference.
-  std::string& str() {
-    flush();
-    return OS;
-  }
-
-  void reserveExtraSpace(uint64_t ExtraSize) override {
-    OS.reserve(tell() + ExtraSize);
-  }
-};
-
-/// A raw_ostream that writes to an SmallVector or SmallString.  This is a
-/// simple adaptor class. This class does not encounter output errors.
-/// raw_svector_ostream operates without a buffer, delegating all memory
-/// management to the SmallString. Thus the SmallString is always up-to-date,
-/// may be used directly and there is no need to call flush().
-class raw_svector_ostream : public raw_pwrite_stream {
-  SmallVectorImpl<char> &OS;
-
-  /// See raw_ostream::write_impl.
-  void write_impl(const char *Ptr, size_t Size) override;
-
-  void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
-
-  /// Return the current position within the stream.
-  uint64_t current_pos() const override;
-
-public:
-  /// Construct a new raw_svector_ostream.
-  ///
-  /// \param O The vector to write to; this should generally have at least 128
-  /// bytes free to avoid any extraneous memory overhead.
-  explicit raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
-    SetUnbuffered();
-  }
-
-  ~raw_svector_ostream() override = default;
-
-  void flush() = delete;
-
-  /// Return a StringRef for the vector contents.
-  StringRef str() const { return StringRef(OS.data(), OS.size()); }
-
-  void reserveExtraSpace(uint64_t ExtraSize) override {
-    OS.reserve(tell() + ExtraSize);
-  }
-};
-
-/// A raw_ostream that discards all output.
-class raw_null_ostream : public raw_pwrite_stream {
-  /// See raw_ostream::write_impl.
-  void write_impl(const char *Ptr, size_t size) override;
-  void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
-
-  /// Return the current position within the stream, not counting the bytes
-  /// currently in the buffer.
-  uint64_t current_pos() const override;
-
-public:
-  explicit raw_null_ostream() = default;
-  ~raw_null_ostream() override;
-};
-
-class buffer_ostream : public raw_svector_ostream {
-  raw_ostream &OS;
-  SmallVector<char, 0> Buffer;
-
-  virtual void anchor() override;
-
-public:
-  buffer_ostream(raw_ostream &OS) : raw_svector_ostream(Buffer), OS(OS) {}
-  ~buffer_ostream() override { OS << str(); }
-};
-
-class buffer_unique_ostream : public raw_svector_ostream {
-  std::unique_ptr<raw_ostream> OS;
-  SmallVector<char, 0> Buffer;
-
-  virtual void anchor() override;
-
-public:
-  buffer_unique_ostream(std::unique_ptr<raw_ostream> OS)
-      : raw_svector_ostream(Buffer), OS(std::move(OS)) {}
-  ~buffer_unique_ostream() override { *OS << str(); }
-};
-
-class Error;
-
-/// This helper creates an output stream and then passes it to \p Write.
-/// The stream created is based on the specified \p OutputFileName:
-/// llvm::outs for "-", raw_null_ostream for "/dev/null", and raw_fd_ostream
-/// for other names. For raw_fd_ostream instances, the stream writes to
-/// a temporary file. The final output file is atomically replaced with the
-/// temporary file after the \p Write function is finished.
-Error writeToOutput(StringRef OutputFileName,
-                    std::function<Error(raw_ostream &)> Write);
-
-} // end namespace llvm
-
-#endif // LLVM_SUPPORT_RAW_OSTREAM_H
diff --git a/symbolic-demangle/vendor/swift/include/llvm/Support/type_traits.h b/symbolic-demangle/vendor/swift/include/llvm/Support/type_traits.h
index 7b7d5d991..3fd158def 100644
--- a/symbolic-demangle/vendor/swift/include/llvm/Support/type_traits.h
+++ b/symbolic-demangle/vendor/swift/include/llvm/Support/type_traits.h
@@ -32,11 +32,11 @@ template <typename T> class is_integral_or_enum {
 
 public:
   static const bool value =
-      !std::is_class<UnderlyingT>::value && // Filter conversion operators.
-      !std::is_pointer<UnderlyingT>::value &&
-      !std::is_floating_point<UnderlyingT>::value &&
-      (std::is_enum<UnderlyingT>::value ||
-       std::is_convertible<UnderlyingT, unsigned long long>::value);
+      !std::is_class_v<UnderlyingT> && // Filter conversion operators.
+      !std::is_pointer_v<UnderlyingT> &&
+      !std::is_floating_point_v<UnderlyingT> &&
+      (std::is_enum_v<UnderlyingT> ||
+       std::is_convertible_v<UnderlyingT, unsigned long long>);
 };
 
 /// If T is a pointer, just return it. If it is not, return T&.
@@ -45,7 +45,7 @@ struct add_lvalue_reference_if_not_pointer { using type = T &; };
 
 template <typename T>
 struct add_lvalue_reference_if_not_pointer<
-    T, std::enable_if_t<std::is_pointer<T>::value>> {
+    T, std::enable_if_t<std::is_pointer_v<T>>> {
   using type = T;
 };
 
@@ -55,7 +55,7 @@ template<typename T, typename Enable = void>
 struct add_const_past_pointer { using type = const T; };
 
 template <typename T>
-struct add_const_past_pointer<T, std::enable_if_t<std::is_pointer<T>::value>> {
+struct add_const_past_pointer<T, std::enable_if_t<std::is_pointer_v<T>>> {
   using type = const std::remove_pointer_t<T> *;
 };
 
@@ -64,27 +64,11 @@ struct const_pointer_or_const_ref {
   using type = const T &;
 };
 template <typename T>
-struct const_pointer_or_const_ref<T,
-                                  std::enable_if_t<std::is_pointer<T>::value>> {
+struct const_pointer_or_const_ref<T, std::enable_if_t<std::is_pointer_v<T>>> {
   using type = typename add_const_past_pointer<T>::type;
 };
 
 namespace detail {
-/// Internal utility to detect trivial copy construction.
-template<typename T> union copy_construction_triviality_helper {
-    T t;
-    copy_construction_triviality_helper() = default;
-    copy_construction_triviality_helper(const copy_construction_triviality_helper&) = default;
-    ~copy_construction_triviality_helper() = default;
-};
-/// Internal utility to detect trivial move construction.
-template<typename T> union move_construction_triviality_helper {
-    T t;
-    move_construction_triviality_helper() = default;
-    move_construction_triviality_helper(move_construction_triviality_helper&&) = default;
-    ~move_construction_triviality_helper() = default;
-};
-
 template<class T>
 union trivial_helper {
     T t;
@@ -92,29 +76,6 @@ union trivial_helper {
 
 } // end namespace detail
 
-/// An implementation of `std::is_trivially_copy_constructible` since we have
-/// users with STLs that don't yet include it.
-template <typename T>
-struct is_trivially_copy_constructible
-    : std::is_copy_constructible<
-          ::llvm::detail::copy_construction_triviality_helper<T>> {};
-template <typename T>
-struct is_trivially_copy_constructible<T &> : std::true_type {};
-template <typename T>
-struct is_trivially_copy_constructible<T &&> : std::false_type {};
-
-/// An implementation of `std::is_trivially_move_constructible` since we have
-/// users with STLs that don't yet include it.
-template <typename T>
-struct is_trivially_move_constructible
-    : std::is_move_constructible<
-          ::llvm::detail::move_construction_triviality_helper<T>> {};
-template <typename T>
-struct is_trivially_move_constructible<T &> : std::true_type {};
-template <typename T>
-struct is_trivially_move_constructible<T &&> : std::true_type {};
-
-
 template <typename T>
 struct is_copy_assignable {
   template<class F>
@@ -131,61 +92,6 @@ struct is_move_assignable {
     static constexpr bool value = decltype(get((T*)nullptr))::value;
 };
 
-
-// An implementation of `std::is_trivially_copyable` since STL version
-// is not equally supported by all compilers, especially GCC 4.9.
-// Uniform implementation of this trait is important for ABI compatibility
-// as it has an impact on SmallVector's ABI (among others).
-template <typename T>
-class is_trivially_copyable {
-
-  // copy constructors
-  static constexpr bool has_trivial_copy_constructor =
-      std::is_copy_constructible<detail::trivial_helper<T>>::value;
-  static constexpr bool has_deleted_copy_constructor =
-      !std::is_copy_constructible<T>::value;
-
-  // move constructors
-  static constexpr bool has_trivial_move_constructor =
-      std::is_move_constructible<detail::trivial_helper<T>>::value;
-  static constexpr bool has_deleted_move_constructor =
-      !std::is_move_constructible<T>::value;
-
-  // copy assign
-  static constexpr bool has_trivial_copy_assign =
-      is_copy_assignable<detail::trivial_helper<T>>::value;
-  static constexpr bool has_deleted_copy_assign =
-      !is_copy_assignable<T>::value;
-
-  // move assign
-  static constexpr bool has_trivial_move_assign =
-      is_move_assignable<detail::trivial_helper<T>>::value;
-  static constexpr bool has_deleted_move_assign =
-      !is_move_assignable<T>::value;
-
-  // destructor
-  static constexpr bool has_trivial_destructor =
-      std::is_destructible<detail::trivial_helper<T>>::value;
-
-  public:
-
-  static constexpr bool value =
-      has_trivial_destructor &&
-      (has_deleted_move_assign || has_trivial_move_assign) &&
-      (has_deleted_move_constructor || has_trivial_move_constructor) &&
-      (has_deleted_copy_assign || has_trivial_copy_assign) &&
-      (has_deleted_copy_constructor || has_trivial_copy_constructor);
-
-#ifdef HAVE_STD_IS_TRIVIALLY_COPYABLE
-  static_assert(value == std::is_trivially_copyable<T>::value,
-                "inconsistent behavior between llvm:: and std:: implementation of is_trivially_copyable");
-#endif
-};
-template <typename T>
-class is_trivially_copyable<T*> : public std::true_type {
-};
-
-
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_TYPE_TRAITS_H
diff --git a/symbolic-demangle/vendor/swift/include/swift/ABI/InvertibleProtocols.def b/symbolic-demangle/vendor/swift/include/swift/ABI/InvertibleProtocols.def
new file mode 100644
index 000000000..507c22dad
--- /dev/null
+++ b/symbolic-demangle/vendor/swift/include/swift/ABI/InvertibleProtocols.def
@@ -0,0 +1,31 @@
+//===--- InvertibleProtocols.def - invertible protocol meta -*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines macros used for macro-metaprogramming with ABI-defined
+// invertible protocols.
+//
+// The INVERTIBLE_PROTOCOL(Name, Bit) macro is used to specify each
+// each invertible protocol that's conceptually part of the ABI. The
+// arguments are:
+//   Name: The name of the protocol, e.g., Copyable
+//   Bit: The bit in the set bitset of invertible protocols that is used
+//        to indicate this.
+//===----------------------------------------------------------------------===//
+
+#ifndef INVERTIBLE_PROTOCOL
+#  error Must define INVERTIBLE_PROTOCOL macro before including this file
+#endif
+
+INVERTIBLE_PROTOCOL(Copyable, 0)
+INVERTIBLE_PROTOCOL(Escapable, 1)
+
+#undef INVERTIBLE_PROTOCOL
diff --git a/symbolic-demangle/vendor/swift/include/swift/AST/Ownership.h b/symbolic-demangle/vendor/swift/include/swift/AST/Ownership.h
index 468d700e4..9ec8ab6b4 100644
--- a/symbolic-demangle/vendor/swift/include/swift/AST/Ownership.h
+++ b/symbolic-demangle/vendor/swift/include/swift/AST/Ownership.h
@@ -19,14 +19,13 @@
 #ifndef SWIFT_OWNERSHIP_H
 #define SWIFT_OWNERSHIP_H
 
-#include "limits.h"
 #include "swift/Basic/InlineBitfield.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/raw_ostream.h"
-#include <stdint.h>
 #include <assert.h>
+#include <limits.h>
+#include <stdint.h>
 
 namespace swift {
 
@@ -76,7 +75,7 @@ static inline bool isLessStrongThan(ReferenceOwnership left,
   auto strengthOf = [] (ReferenceOwnership ownership) -> int {
     // A reference can be optimized away if outlived by a stronger reference.
     // NOTES:
-    // 1) Different reference kinds of the same strength are NOT interchangable.
+    // 1) Different reference kinds of the same strength are NOT interchangeable.
     // 2) Stronger than "strong" might include locking, for example.
     // 3) Unchecked references must be last to preserve identity comparisons
     //     until the last checked reference is dead.
@@ -118,19 +117,24 @@ optionalityOf(ReferenceOwnership ownership) {
   llvm_unreachable("impossible");
 }
 
-/// Diagnostic printing of \c StaticSpellingKind.
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, ReferenceOwnership RO);
-
 /// Different kinds of value ownership supported by Swift.
+///
+/// The order of these constants is significant. Ascending order indicates
+/// stricter requirements on the value to be used with the given ownership
+/// kind: any value can be accessed with a shared borrow (so long as there
+/// are no exclusive accesses overlapping). An exclusive `inout` borrow is
+/// only possible for mutable values which the caller already has exclusive
+/// access to or ownership of. Consumption of an owned value requires sole
+/// ownership of that value.
 enum class ValueOwnership : uint8_t {
   /// the context-dependent default ownership (sometimes shared,
   /// sometimes owned)
   Default,
-  /// an 'inout' mutating pointer-like value
-  InOut,
-  /// a '__shared' non-mutating pointer-like value
+  /// a 'borrowing' nonexclusive, usually nonmutating borrow
   Shared,
-  /// an '__owned' value
+  /// an 'inout' exclusive, mutating borrow
+  InOut,
+  /// a 'consuming' ownership transfer
   Owned,
 
   Last_Kind = Owned
@@ -138,6 +142,27 @@ enum class ValueOwnership : uint8_t {
 enum : unsigned { NumValueOwnershipBits =
   countBitsUsed(static_cast<unsigned>(ValueOwnership::Last_Kind)) };
 
+enum class ParameterOwnership : uint8_t;
+
+/// Map a `ValueOwnership` to the corresponding ABI-stable constant used by
+/// runtime metadata.
+ParameterOwnership asParameterOwnership(ValueOwnership o);
+/// Map an ABI-stable ownership identifier to a `ValueOwnership`.
+ValueOwnership asValueOwnership(ParameterOwnership o);
+
+static inline llvm::StringRef getOwnershipSpelling(ValueOwnership ownership) {
+  switch (ownership) {
+  case ValueOwnership::Default:
+    return "";
+  case ValueOwnership::InOut:
+    return "inout";
+  case ValueOwnership::Shared:
+    return "borrowing";
+  case ValueOwnership::Owned:
+    return "consuming";
+  }
+  llvm_unreachable("Invalid ValueOwnership");
+}
 } // end namespace swift
 
 #endif
diff --git a/symbolic-demangle/vendor/swift/include/swift/Basic/Compiler.h b/symbolic-demangle/vendor/swift/include/swift/Basic/Compiler.h
deleted file mode 100644
index e181a2413..000000000
--- a/symbolic-demangle/vendor/swift/include/swift/Basic/Compiler.h
+++ /dev/null
@@ -1,165 +0,0 @@
-//===--- Compiler.h - Compiler specific definitions -------------*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef SWIFT_BASIC_COMPILER_H
-#define SWIFT_BASIC_COMPILER_H
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#define SWIFT_COMPILER_IS_MSVC 1
-#else
-#define SWIFT_COMPILER_IS_MSVC 0
-#endif
-
-// Workaround non-clang compilers
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-#ifndef __has_attribute
-#define __has_attribute(x) 0
-#endif
-
-// __builtin_assume() is an optimization hint.
-#if __has_builtin(__builtin_assume)
-#define SWIFT_ASSUME(x) __builtin_assume(x)
-#else
-#define SWIFT_ASSUME(x)
-#endif
-
-/// Attributes.
-
-#if __has_attribute(constructor)
-#define SWIFT_CONSTRUCTOR __attribute__((constructor))
-#else
-#define SWIFT_CONSTRUCTOR
-#endif
-
-/// \macro SWIFT_GNUC_PREREQ
-/// Extend the default __GNUC_PREREQ even if glibc's features.h isn't
-/// available.
-#ifndef SWIFT_GNUC_PREREQ
-# if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
-#  define SWIFT_GNUC_PREREQ(maj, min, patch) \
-    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
-     ((maj) << 20) + ((min) << 10) + (patch))
-# elif defined(__GNUC__) && defined(__GNUC_MINOR__)
-#  define SWIFT_GNUC_PREREQ(maj, min, patch) \
-    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
-# else
-#  define SWIFT_GNUC_PREREQ(maj, min, patch) 0
-# endif
-#endif
-
-
-/// SWIFT_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
-/// mark a method "not for inlining".
-#if __has_attribute(noinline) || SWIFT_GNUC_PREREQ(3, 4, 0)
-#define SWIFT_ATTRIBUTE_NOINLINE __attribute__((noinline))
-#elif defined(_MSC_VER)
-#define SWIFT_ATTRIBUTE_NOINLINE __declspec(noinline)
-#else
-#define SWIFT_ATTRIBUTE_NOINLINE
-#endif
-
-/// SWIFT_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
-/// so, mark a method "always inline" because it is performance sensitive. GCC
-/// 3.4 supported this but is buggy in various cases and produces unimplemented
-/// errors, just use it in GCC 4.0 and later.
-#if __has_attribute(always_inline) || SWIFT_GNUC_PREREQ(4, 0, 0)
-#define SWIFT_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#define SWIFT_ATTRIBUTE_ALWAYS_INLINE __forceinline
-#else
-#define SWIFT_ATTRIBUTE_ALWAYS_INLINE
-#endif
-
-#ifdef __GNUC__
-#define SWIFT_ATTRIBUTE_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define SWIFT_ATTRIBUTE_NORETURN __declspec(noreturn)
-#else
-#define SWIFT_ATTRIBUTE_NORETURN
-#endif
-
-#ifndef SWIFT_BUG_REPORT_URL
-#define SWIFT_BUG_REPORT_URL "https://swift.org/contributing/#reporting-bugs"
-#endif
-
-#define SWIFT_BUG_REPORT_MESSAGE_BASE \
-  "submit a bug report (" SWIFT_BUG_REPORT_URL \
-  ") and include the project"
-
-#define SWIFT_BUG_REPORT_MESSAGE \
-  "please " SWIFT_BUG_REPORT_MESSAGE_BASE
-
-#define SWIFT_CRASH_BUG_REPORT_MESSAGE \
-  "Please " SWIFT_BUG_REPORT_MESSAGE_BASE " and the crash backtrace."
-
-// Conditionally exclude declarations or statements that are only needed for
-// assertions from release builds (NDEBUG) without cluttering the surrounding
-// code by #ifdefs.
-//
-// struct DoThings  {
-//   SWIFT_ASSERT_ONLY_DECL(unsigned verifyCount = 0);
-//   DoThings() {
-//     SWIFT_ASSERT_ONLY(verifyCount = getNumberOfThingsToDo());
-//   }
-//   void doThings() {
-//     do {
-//       // ... do each thing
-//       SWIFT_ASSERT_ONLY(--verifyCount);
-//     } while (!done());
-//     assert(verifyCount == 0 && "did not do everything");
-//   }
-// };
-#ifdef NDEBUG
-#define SWIFT_ASSERT_ONLY_DECL(...)
-#define SWIFT_ASSERT_ONLY(...) do { } while (false)
-#else
-#define SWIFT_ASSERT_ONLY_DECL(...) __VA_ARGS__
-#define SWIFT_ASSERT_ONLY(...) do { __VA_ARGS__; } while (false)
-#endif
-
-#if defined(__LP64__) || defined(_WIN64)
-#define SWIFT_POINTER_IS_8_BYTES 1
-#define SWIFT_POINTER_IS_4_BYTES 0
-#else
-// TODO: consider supporting 16-bit targets
-#define SWIFT_POINTER_IS_8_BYTES 0
-#define SWIFT_POINTER_IS_4_BYTES 1
-#endif
-
-// Produce a string literal for the raw argument tokens.
-#define SWIFT_STRINGIZE_RAW(TOK) #TOK
-
-// Produce a string literal for the macro-expanded argument tokens.
-#define SWIFT_STRINGIZE_EXPANDED(TOK) SWIFT_STRINGIZE_RAW(TOK)
-
-#if defined(__USER_LABEL_PREFIX__)
-#define SWIFT_SYMBOL_PREFIX_STRING \
-  SWIFT_STRINGIZE_EXPANDED(__USER_LABEL_PREFIX__)
-#else
-// Clang and GCC always define __USER_LABEL_PREFIX__, so this should
-// only come up with MSVC, and Windows doesn't use a prefix.
-#define SWIFT_SYMBOL_PREFIX_STRING ""
-#endif
-
-// An attribute to override the symbol name of a declaration.
-// This does not compensate for platform symbol prefixes; for that,
-// use SWIFT_ASM_LABEL_WITH_PREFIX.
-//
-// This only actually works on Clang or GCC; MSVC does not provide
-// an attribute to change the asm label.
-#define SWIFT_ASM_LABEL_RAW(STRING) __asm__(STRING)
-#define SWIFT_ASM_LABEL_WITH_PREFIX(STRING) \
-  SWIFT_ASM_LABEL_RAW(SWIFT_SYMBOL_PREFIX_STRING STRING)
-
-#endif // SWIFT_BASIC_COMPILER_H
diff --git a/symbolic-demangle/vendor/swift/include/swift/Basic/LLVM.h b/symbolic-demangle/vendor/swift/include/swift/Basic/LLVM.h
index 40ab0fe66..827d360b8 100644
--- a/symbolic-demangle/vendor/swift/include/swift/Basic/LLVM.h
+++ b/symbolic-demangle/vendor/swift/include/swift/Basic/LLVM.h
@@ -22,9 +22,15 @@
 // dependencies.
 // Casting.h has complex templates that cannot be easily forward declared.
 #include "llvm/Support/Casting.h"
-// None.h includes an enumerator that is desired & cannot be forward declared
-// without a definition of NoneType.
-#include "llvm/ADT/None.h"
+
+#if defined(__clang_major__) && __clang_major__ < 6
+// Add this header as a workaround to prevent `too few template arguments for
+// class template 'SmallVector'` on the buggy Clang 5 compiler (it doesn't
+// merge template arguments correctly). Remove once the CentOS 7 job is
+// replaced.
+// rdar://98218902
+#include "llvm/ADT/SmallVector.h"
+#endif
 
 // Don't pre-declare certain LLVM types in the runtime, which must
 // not put things in namespace llvm for ODR reasons.
@@ -47,15 +53,12 @@ namespace llvm {
   template <typename T, unsigned N> class SmallVector;
 #endif
   template <unsigned N> class SmallString;
-  template <typename T, unsigned N> class SmallSetVector;
 #if SWIFT_LLVM_ODR_SAFE
   template<typename T> class ArrayRef;
   template<typename T> class MutableArrayRef;
 #endif
-  template<typename T> class TinyPtrVector;
-#if SWIFT_LLVM_ODR_SAFE
-  template<typename T> class Optional;
-#endif
+  template <typename T>
+  class TinyPtrVector;
   template <typename ...PTs> class PointerUnion;
   template <typename IteratorT> class iterator_range;
   class SmallBitVector;
@@ -73,6 +76,7 @@ namespace llvm {
 namespace swift {
   // Casting operators.
   using llvm::isa;
+  using llvm::isa_and_nonnull;
   using llvm::cast;
   using llvm::dyn_cast;
   using llvm::dyn_cast_or_null;
@@ -84,15 +88,10 @@ namespace swift {
   using llvm::MutableArrayRef;
 #endif
   using llvm::iterator_range;
-  using llvm::None;
-#if SWIFT_LLVM_ODR_SAFE
-  using llvm::Optional;
-#endif
   using llvm::PointerUnion;
   using llvm::SmallBitVector;
   using llvm::SmallPtrSet;
   using llvm::SmallPtrSetImpl;
-  using llvm::SmallSetVector;
   using llvm::SmallString;
 #if SWIFT_LLVM_ODR_SAFE
   using llvm::SmallVector;
@@ -109,7 +108,6 @@ namespace swift {
 #if SWIFT_LLVM_ODR_SAFE
   using llvm::function_ref;
 #endif
-  using llvm::NoneType;
   using llvm::raw_ostream;
 } // end namespace swift
 
diff --git a/symbolic-demangle/vendor/swift/include/swift/Basic/MacroRoles.def b/symbolic-demangle/vendor/swift/include/swift/Basic/MacroRoles.def
new file mode 100644
index 000000000..1121bb4bb
--- /dev/null
+++ b/symbolic-demangle/vendor/swift/include/swift/Basic/MacroRoles.def
@@ -0,0 +1,90 @@
+//===--- MacroRoles.def - Known macro roles --*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines all of the kinds of macro roles. Clients should define
+// either MACRO_ROLE or both ATTACHED_MACRO_ROLE and FREESTANDING_MACRO_ROLE.
+//
+// The order of the macro roles in this file is significant for the
+// serialization of module files. Please do not re-order the entries without
+// also bumping the module format version. When introducing new macro roles,
+// please add them to the end of the file.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ATTACHED_MACRO_ROLE
+#  define ATTACHED_MACRO_ROLE(Name, Description, MangledChar) MACRO_ROLE(Name, Description)
+#endif
+
+#ifndef FREESTANDING_MACRO_ROLE
+#  define FREESTANDING_MACRO_ROLE(Name, Description) MACRO_ROLE(Name, Description)
+#endif
+
+#ifndef EXPERIMENTAL_ATTACHED_MACRO_ROLE
+#  define EXPERIMENTAL_ATTACHED_MACRO_ROLE(Name, Description, MangledChar, Feature) \
+     ATTACHED_MACRO_ROLE(Name, Description, MangledChar)
+#endif
+
+#ifndef EXPERIMENTAL_FREESTANDING_MACRO_ROLE
+#  define EXPERIMENTAL_FREESTANDING_MACRO_ROLE(Name, Description, Feature) \
+     FREESTANDING_MACRO_ROLE(Name, Description)
+#endif
+
+/// An expression macro, referenced explicitly via "#stringify" or similar
+/// in the source code.
+FREESTANDING_MACRO_ROLE(Expression, "expression")
+
+/// A freestanding declaration macro.
+FREESTANDING_MACRO_ROLE(Declaration, "declaration")
+
+
+/// An attached macro that declares accessors for a variable or subscript
+/// declaration.
+ATTACHED_MACRO_ROLE(Accessor, "accessor", "a")
+
+/// An attached macro that generates attributes for the
+/// members inside the declaration.
+ATTACHED_MACRO_ROLE(MemberAttribute, "memberAttribute", "r")
+
+/// An attached macro that generates synthesized members
+/// inside the declaration.
+ATTACHED_MACRO_ROLE(Member, "member", "m")
+
+/// An attached macro that generates declarations that are peers
+/// of the declaration the macro is attached to.
+ATTACHED_MACRO_ROLE(Peer, "peer", "p")
+
+/// An attached macro that adds conformances to the declaration the
+/// macro is attached to.
+ATTACHED_MACRO_ROLE(Conformance, "conformance", "c")
+
+/// A freestanding macro that expands to expressions, statements and
+/// declarations in a code block.
+EXPERIMENTAL_FREESTANDING_MACRO_ROLE(CodeItem, "codeItem", CodeItemMacros)
+
+/// An attached macro that adds extensions to the declaration the
+/// macro is attached to.
+ATTACHED_MACRO_ROLE(Extension, "extension", "e")
+
+/// An attached macro that expands to a preamble to a function.
+EXPERIMENTAL_ATTACHED_MACRO_ROLE(Preamble, "preamble", "q", PreambleMacros)
+
+/// An attached macro that expands to a function body.
+ATTACHED_MACRO_ROLE(Body, "body", "b")
+
+#undef ATTACHED_MACRO_ROLE
+#undef FREESTANDING_MACRO_ROLE
+#undef EXPERIMENTAL_ATTACHED_MACRO_ROLE
+#undef EXPERIMENTAL_FREESTANDING_MACRO_ROLE
+
+#ifdef MACRO_ROLE
+#  undef MACRO_ROLE
+#endif
diff --git a/symbolic-demangle/vendor/swift/include/swift/Basic/STLExtras.h b/symbolic-demangle/vendor/swift/include/swift/Basic/STLExtras.h
index 26ecbc4f8..28a721317 100644
--- a/symbolic-demangle/vendor/swift/include/swift/Basic/STLExtras.h
+++ b/symbolic-demangle/vendor/swift/include/swift/Basic/STLExtras.h
@@ -14,11 +14,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SWIFT_BASIC_INTERLEAVE_H
-#define SWIFT_BASIC_INTERLEAVE_H
+#ifndef SWIFT_BASIC_STLEXTRAS_H
+#define SWIFT_BASIC_STLEXTRAS_H
 
-#include "swift/Basic/LLVM.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Casting.h"
 #include <algorithm>
@@ -26,6 +24,7 @@
 #include <functional>
 #include <iterator>
 #include <numeric>
+#include <optional>
 #include <type_traits>
 #include <unordered_set>
 
@@ -405,7 +404,7 @@ class OptionalTransformIterator {
       typename std::iterator_traits<Iterator>::reference;
 
   using ResultReference =
-      typename std::result_of<OptionalTransform(UnderlyingReference)>::type;
+      typename std::invoke_result<OptionalTransform, UnderlyingReference>::type;
 
 public:
   /// Used to indicate when the current iterator has already been
@@ -527,20 +526,20 @@ template<typename Subclass>
 struct DowncastAsOptional {
   template <typename Superclass>
   auto operator()(Superclass &value) const
-      -> llvm::Optional<decltype(llvm::cast<Subclass>(value))> {
+      -> std::optional<decltype(llvm::cast<Subclass>(value))> {
     if (auto result = llvm::dyn_cast<Subclass>(value))
       return result;
 
-    return None;
+    return std::nullopt;
   }
 
   template <typename Superclass>
   auto operator()(const Superclass &value) const
-      -> llvm::Optional<decltype(llvm::cast<Subclass>(value))> {
+      -> std::optional<decltype(llvm::cast<Subclass>(value))> {
     if (auto result = llvm::dyn_cast<Subclass>(value))
       return result;
 
-    return None;
+    return std::nullopt;
   }
 };
 
@@ -769,6 +768,31 @@ erase_if(std::unordered_set<Key, Hash, KeyEqual, Alloc> &c, Pred pred) {
   return startingSize - c.size();
 }
 
+/// Call \c vector.emplace_back with each of the other arguments
+/// to this function, in order.  Constructing an intermediate
+/// \c std::initializer_list can be inefficient; more problematically,
+/// types such as \c std::vector copy out of the \c initializer_list
+/// instead of move.
+template <class VectorType, class ValueType, class... ValueTypes>
+void emplace_back_all(VectorType &vector, ValueType &&value,
+                      ValueTypes &&...values) {
+  vector.emplace_back(std::forward<ValueType>(value));
+  emplace_back_all(vector, std::forward<ValueTypes>(values)...);
+}
+template <class VectorType>
+void emplace_back_all(VectorType &vector) {}
+
+/// Apply a function to the value if present; otherwise return None.
+template <typename OptionalElement, typename Function>
+auto transform(const std::optional<OptionalElement> &value,
+               const Function &operation)
+    -> std::optional<decltype(operation(*value))> {
+
+  if (value) {
+    return operation(*value);
+  }
+  return std::nullopt;
+}
 } // end namespace swift
 
-#endif // SWIFT_BASIC_INTERLEAVE_H
+#endif // SWIFT_BASIC_STLEXTRAS_H
diff --git a/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangle.h b/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangle.h
index f48e1c26d..940c36520 100644
--- a/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangle.h
+++ b/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangle.h
@@ -19,17 +19,16 @@
 #ifndef SWIFT_DEMANGLING_DEMANGLE_H
 #define SWIFT_DEMANGLING_DEMANGLE_H
 
-#include <memory>
-#include <string>
-#include <cassert>
-#include <cstdint>
-#include "llvm/ADT/StringRef.h"
-#include "swift/Runtime/Config.h"
+#include "swift/Demangling/Errors.h"
 #include "swift/Demangling/NamespaceMacros.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Compiler.h"
 
-namespace llvm {
-  class raw_ostream;
-}
+#include <cassert>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
 
 namespace swift {
 namespace Demangle {
@@ -65,6 +64,7 @@ struct DemangleOptions {
   bool DisplayObjCModule = true;
   bool PrintForTypeName = false;
   bool ShowAsyncResumePartial = true;
+  bool ShowClosureSignature = true;
 
   /// If this is nonempty, entities in this module name will not be qualified.
   llvm::StringRef HidingCurrentModule;
@@ -92,6 +92,7 @@ struct DemangleOptions {
     Opt.ShowPrivateDiscriminators = false;
     Opt.ShowFunctionArgumentTypes = false;
     Opt.ShowFunctionReturnType = false;
+    Opt.ShowAsyncResumePartial = false;
     return Opt;
   };
 };
@@ -110,6 +111,8 @@ enum class FunctionSigSpecializationParamKind : unsigned {
   ClosureProp = 5,
   BoxToValue = 6,
   BoxToStack = 7,
+  InOutToOut = 8,
+  ConstantPropKeyPath = 9,
 
   // Option Set Flags use bits 6-31. This gives us 26 bits to use for option
   // flags.
@@ -135,19 +138,30 @@ enum class MangledDifferentiabilityKind : char {
   Linear = 'l',
 };
 
+enum class MangledLifetimeDependenceKind : char { Inherit = 'i', Scope = 's' };
+
 /// The pass that caused the specialization to occur. We use this to make sure
 /// that two passes that generate similar changes do not yield the same
 /// mangling. This currently cannot happen, so this is just a safety measure
 /// that creates separate name spaces.
+///
+/// The number of entries is limited! See `Demangler::demangleSpecAttributes`.
+/// If you exceed the max, you'll need to upgrade the mangling.
 enum class SpecializationPass : uint8_t {
-  AllocBoxToStack,
+  AllocBoxToStack = 0,
   ClosureSpecializer,
   CapturePromotion,
   CapturePropagation,
   FunctionSignatureOpts,
   GenericSpecializer,
+  MoveDiagnosticInOutToOut,
+  AsyncDemotion,
+  LAST = AsyncDemotion
 };
 
+constexpr uint8_t MAX_SPECIALIZATION_PASS = 10;
+static_assert((uint8_t)SpecializationPass::LAST < MAX_SPECIALIZATION_PASS);
+
 static inline char encodeSpecializationPass(SpecializationPass Pass) {
   return char(uint8_t(Pass)) + '0';
 }
@@ -195,7 +209,8 @@ class Node {
   Kind NodeKind;
 
   enum class PayloadKind : uint8_t {
-    None, Text, Index, OneChild, TwoChildren, ManyChildren
+    None = 0, OneChild = 1, TwoChildren = 2,
+    Text, Index, ManyChildren
   };
   PayloadKind NodePayloadKind;
 
@@ -216,6 +231,22 @@ class Node {
 public:
   Kind getKind() const { return NodeKind; }
 
+  bool isSimilarTo(const Node *other) const {
+    if (NodeKind != other->NodeKind
+        || NodePayloadKind != other->NodePayloadKind)
+      return false;
+    switch (NodePayloadKind) {
+    case PayloadKind::ManyChildren:
+      return Children.Number == other->Children.Number;
+    case PayloadKind::Index:
+      return Index == other->Index;
+    case PayloadKind::Text:
+      return Text == other->Text;
+    default:
+      return true;
+    }
+  }
+
   bool hasText() const { return NodePayloadKind == PayloadKind::Text; }
   llvm::StringRef getText() const {
     assert(hasText());
@@ -230,13 +261,41 @@ class Node {
 
   using iterator = const NodePointer *;
 
-  size_t getNumChildren() const;
+  size_t getNumChildren() const {
+    switch (NodePayloadKind) {
+    case PayloadKind::OneChild: return 1;
+    case PayloadKind::TwoChildren: return 2;
+    case PayloadKind::ManyChildren: return Children.Number;
+    default: return 0;
+    }
+  }
 
   bool hasChildren() const { return getNumChildren() != 0; }
 
-  iterator begin() const;
+  iterator begin() const {
+    switch (NodePayloadKind) {
+    case PayloadKind::OneChild:
+    case PayloadKind::TwoChildren:
+      return &InlineChildren[0];
+    case PayloadKind::ManyChildren:
+      return Children.Nodes;
+    default:
+      return nullptr;
+    }
+  }
 
-  iterator end() const;
+  iterator end() const {
+    switch (NodePayloadKind) {
+    case PayloadKind::OneChild:
+      return &InlineChildren[1];
+    case PayloadKind::TwoChildren:
+      return &InlineChildren[2];
+    case PayloadKind::ManyChildren:
+      return Children.Nodes + Children.Number;
+    default:
+      return nullptr;
+    }
+  }
 
   NodePointer getFirstChild() const {
     return getChild(0);
@@ -245,7 +304,8 @@ class Node {
     return getChild(getNumChildren() - 1);
   }
   NodePointer getChild(size_t index) const {
-    assert(getNumChildren() > index);
+    if (index >= getNumChildren())
+      return nullptr;
     return begin()[index];
   }
 
@@ -254,13 +314,19 @@ class Node {
   // Only to be used by the demangler parsers.
   void removeChildAt(unsigned Pos);
 
+  void replaceChild(unsigned Pos, NodePointer Child);
+
   // Reverses the order of children.
   void reverseChildren(size_t StartingAt = 0);
 
+  // Find a node by its kind, traversing the node depth-first,
+  // and bailing out early if not found at the 'maxDepth'.
+  NodePointer findByKind(Node::Kind kind, int maxDepth);
+
   /// Prints the whole node tree in readable form to stderr.
   ///
   /// Useful to be called from the debugger.
-  void dump();
+  void dump() LLVM_ATTRIBUTE_USED;
 };
 
 /// Returns the length of the swift mangling prefix of the \p SymbolName.
@@ -515,8 +581,77 @@ enum class OperatorKind {
   Infix,
 };
 
+/// A mangling error, which consists of an error code and a Node pointer
+struct [[nodiscard]] ManglingError {
+  enum Code {
+    Success = 0,
+    AssertionFailed,
+    Uninitialized,
+    TooComplex,
+    BadNodeKind,
+    BadNominalTypeKind,
+    NotAStorageNode,
+    UnsupportedNodeKind,
+    UnexpectedBuiltinVectorType,
+    UnexpectedBuiltinType,
+    MultipleChildNodes,
+    WrongNodeType,
+    WrongDependentMemberType,
+    BadDirectness,
+    UnknownEncoding,
+    InvalidImplCalleeConvention,
+    InvalidImplDifferentiability,
+    InvalidImplFunctionAttribute,
+    InvalidImplParameterConvention,
+    InvalidImplParameterSending,
+    InvalidMetatypeRepresentation,
+    MultiByteRelatedEntity,
+    BadValueWitnessKind,
+    NotAContextNode,
+  };
+
+  Code        code;
+  NodePointer node;
+  unsigned    line;
+
+  ManglingError() : code(Uninitialized), node(nullptr) {}
+  ManglingError(Code c) : code(c), node(nullptr), line(0) {}
+  ManglingError(Code c, NodePointer n, unsigned l) : code(c), node(n), line(l) {}
+
+  bool isSuccess() const { return code == Success; }
+};
+
+#define MANGLING_ERROR(c,n)     ManglingError((c), (n), __LINE__)
+
+/// Used as a return type for mangling functions that may fail
+template <typename T>
+class [[nodiscard]] ManglingErrorOr {
+private:
+  ManglingError err_;
+  T             value_;
+
+public:
+  ManglingErrorOr() : err_() {}
+  ManglingErrorOr(ManglingError::Code code,
+                  NodePointer node = nullptr,
+                  unsigned line = 0)
+  : err_(code, node, line) {}
+  ManglingErrorOr(const ManglingError &err) : err_(err) {}
+  ManglingErrorOr(const T &t) : err_(ManglingError::Success), value_(t) {}
+  ManglingErrorOr(T &&t) : err_(ManglingError::Success), value_(std::move(t)) {}
+
+  bool isSuccess() const { return err_.code == ManglingError::Success; }
+
+  const ManglingError &error() const { return err_; }
+
+  const T &result() const {
+    assert(isSuccess());
+    return value_;
+  }
+};
+
 /// Remangle a demangled parse tree.
-std::string mangleNode(NodePointer root);
+ManglingErrorOr<std::string> mangleNode(NodePointer root);
 
 using SymbolicResolver =
   llvm::function_ref<Demangle::NodePointer (SymbolicReferenceKind,
@@ -524,33 +659,36 @@ using SymbolicResolver =
 
 /// Remangle a demangled parse tree, using a callback to resolve
 /// symbolic references.
-std::string mangleNode(NodePointer root, SymbolicResolver resolver);
+ManglingErrorOr<std::string> mangleNode(NodePointer root, SymbolicResolver resolver);
 
 /// Remangle a demangled parse tree, using a callback to resolve
 /// symbolic references.
 ///
 /// The returned string is owned by \p Factory. This means \p Factory must stay
 /// alive as long as the returned string is used.
-llvm::StringRef mangleNode(NodePointer root, SymbolicResolver resolver,
-                           NodeFactory &Factory);
+ManglingErrorOr<llvm::StringRef> mangleNode(NodePointer root,
+                                            SymbolicResolver resolver,
+                                            NodeFactory &Factory);
 
 /// Remangle in the old mangling scheme.
 ///
 /// This is only used for objc-runtime names.
-std::string mangleNodeOld(NodePointer root);
+ManglingErrorOr<std::string> mangleNodeOld(NodePointer root);
 
 /// Remangle in the old mangling scheme.
 ///
 /// This is only used for objc-runtime names.
 /// The returned string is owned by \p Factory. This means \p Factory must stay
 /// alive as long as the returned string is used.
-llvm::StringRef mangleNodeOld(NodePointer node, NodeFactory &Factory);
+ManglingErrorOr<llvm::StringRef> mangleNodeOld(NodePointer node,
+                                               NodeFactory &Factory);
 
 /// Remangle in the old mangling scheme and embed the name in "_Tt<name>_".
 ///
 /// The returned string is null terminated and owned by \p Factory. This means
 /// \p Factory must stay alive as long as the returned string is used.
-const char *mangleNodeAsObjcCString(NodePointer node, NodeFactory &Factory);
+ManglingErrorOr<const char *> mangleNodeAsObjcCString(NodePointer node,
+                                                      NodeFactory &Factory);
 
 /// Transform the node structure to a string.
 ///
@@ -568,6 +706,11 @@ const char *mangleNodeAsObjcCString(NodePointer node, NodeFactory &Factory);
 std::string nodeToString(NodePointer Root,
                          const DemangleOptions &Options = DemangleOptions());
 
+/// Transforms a mangled key path accessor thunk helper
+/// into the identfier/subscript that would be used to invoke it in swift code.
+std::string keyPathSourceString(const char *MangledName,
+                                size_t MangledNameLength);
+
 /// A class for printing to a std::string.
 class DemanglerPrinter {
 public:
@@ -629,7 +772,7 @@ bool nodeConsumesGenericArgs(Node *node);
 
 bool isSpecialized(Node *node);
 
-NodePointer getUnspecialized(Node *node, NodeFactory &Factory);
+ManglingErrorOr<NodePointer> getUnspecialized(Node *node, NodeFactory &Factory);
 
 /// Returns true if the node \p kind refers to a context node, e.g. a nominal
 /// type or a function.
@@ -643,34 +786,14 @@ bool isFunctionAttr(Node::Kind kind);
 /// contain symbolic references.
 llvm::StringRef makeSymbolicMangledNameStringRef(const char *base);
 
+/// Produce the mangled name for the nominal type descriptor of a type
+/// referenced by its module and type name.
+std::string mangledNameForTypeMetadataAccessor(llvm::StringRef moduleName,
+                                               llvm::StringRef typeName,
+                                               Node::Kind typeKind);
+
 SWIFT_END_INLINE_NAMESPACE
 } // end namespace Demangle
 } // end namespace swift
 
-// NB: This function is not used directly in the Swift codebase, but is
-// exported for Xcode support and is used by the sanitizers. Please coordinate
-// before changing.
-//
-/// Demangles a Swift symbol name.
-///
-/// \param mangledName is the symbol name that needs to be demangled.
-/// \param mangledNameLength is the length of the string that should be
-/// demangled.
-/// \param outputBuffer is the user provided buffer where the demangled name
-/// will be placed. If nullptr, a new buffer will be malloced. In that case,
-/// the user of this API is responsible for freeing the returned buffer.
-/// \param outputBufferSize is the size of the output buffer. If the demangled
-/// name does not fit into the outputBuffer, the output will be truncated and
-/// the size will be updated, indicating how large the buffer should be.
-/// \param flags can be used to select the demangling style. TODO: We should
-//// define what these will be.
-/// \returns the demangled name. Returns nullptr if the input String is not a
-/// Swift mangled name.
-SWIFT_RUNTIME_EXPORT
-char *swift_demangle(const char *mangledName,
-                     size_t mangledNameLength,
-                     char *outputBuffer,
-                     size_t *outputBufferSize,
-                     uint32_t flags);
-
 #endif // SWIFT_DEMANGLING_DEMANGLE_H
diff --git a/symbolic-demangle/vendor/swift/include/swift/Demangling/DemangleNodes.def b/symbolic-demangle/vendor/swift/include/swift/Demangling/DemangleNodes.def
index d3ad6b828..c872f1be9 100644
--- a/symbolic-demangle/vendor/swift/include/swift/Demangling/DemangleNodes.def
+++ b/symbolic-demangle/vendor/swift/include/swift/Demangling/DemangleNodes.def
@@ -32,9 +32,11 @@ NODE(AssociatedType)
 NODE(AssociatedTypeRef)
 NODE(AssociatedTypeMetadataAccessor)
 NODE(DefaultAssociatedTypeMetadataAccessor)
+NODE(AccessorAttachedMacroExpansion)
 NODE(AssociatedTypeWitnessTableAccessor)
 NODE(BaseWitnessTableAccessor)
 NODE(AutoClosureType)
+NODE(BodyAttachedMacroExpansion)
 NODE(BoundGenericClass)
 NODE(BoundGenericEnum)
 NODE(BoundGenericStructure)
@@ -43,11 +45,14 @@ NODE(BoundGenericOtherNominalType)
 NODE(BoundGenericTypeAlias)
 NODE(BoundGenericFunction)
 NODE(BuiltinTypeName)
+NODE(BuiltinTupleType)
 NODE(CFunctionPointer)
 NODE(ClangType)
 CONTEXT_NODE(Class)
 NODE(ClassMetadataBaseOffset)
 NODE(ConcreteProtocolConformance)
+NODE(PackProtocolConformance)
+NODE(ConformanceAttachedMacroExpansion)
 CONTEXT_NODE(Constructor)
 NODE(CoroutineContinuationPrototype)
 CONTEXT_NODE(Deallocator)
@@ -59,7 +64,9 @@ NODE(DependentGenericConformanceRequirement)
 NODE(DependentGenericParamCount)
 NODE(DependentGenericParamType)
 NODE(DependentGenericSameTypeRequirement)
+NODE(DependentGenericSameShapeRequirement)
 NODE(DependentGenericLayoutRequirement)
+NODE(DependentGenericParamPackMarker)
 NODE(DependentGenericSignature)
 NODE(DependentGenericType)
 NODE(DependentMemberType)
@@ -70,6 +77,8 @@ NODE(DependentProtocolConformanceAssociated)
 CONTEXT_NODE(Destructor)
 CONTEXT_NODE(DidSet)
 NODE(Directness)
+NODE(DistributedThunk)
+NODE(DistributedAccessor)
 NODE(DynamicAttribute)
 NODE(DirectMethodReferenceAttribute)
 NODE(DynamicSelf)
@@ -87,7 +96,9 @@ NODE(DifferentiableFunctionType)
 NODE(ExistentialMetatype)
 CONTEXT_NODE(ExplicitClosure)
 CONTEXT_NODE(Extension)
+NODE(ExtensionAttachedMacroExpansion)
 NODE(FieldOffset)
+NODE(FreestandingMacroExpansion)
 NODE(FullTypeMetadata)
 CONTEXT_NODE(Function)
 NODE(FunctionSignatureSpecialization)
@@ -96,6 +107,9 @@ NODE(FunctionSignatureSpecializationReturn)
 NODE(FunctionSignatureSpecializationParamKind)
 NODE(FunctionSignatureSpecializationParamPayload)
 NODE(FunctionType)
+NODE(ConstrainedExistential)
+NODE(ConstrainedExistentialRequirementList)
+NODE(ConstrainedExistentialSelf)
 NODE(GenericPartialSpecialization)
 NODE(GenericPartialSpecializationNotReAbstracted)
 NODE(GenericProtocolWitnessTable)
@@ -118,7 +132,10 @@ CONTEXT_NODE(IVarDestroyer)
 NODE(ImplEscaping)
 NODE(ImplConvention)
 NODE(ImplDifferentiabilityKind)
+NODE(ImplErasedIsolation)
+NODE(ImplSendingResult)
 NODE(ImplParameterResultDifferentiability)
+NODE(ImplParameterSending)
 NODE(ImplFunctionAttribute)
 NODE(ImplFunctionConvention)
 NODE(ImplFunctionConventionName)
@@ -133,7 +150,11 @@ NODE(ImplErrorResult)
 NODE(InOut)
 NODE(InfixOperator)
 CONTEXT_NODE(Initializer)
+CONTEXT_NODE(InitAccessor)
 NODE(Isolated)
+NODE(Sending)
+NODE(IsolatedAnyFunctionType)
+NODE(SendingResultFunctionType)
 NODE(KeyPathGetterThunkHelper)
 NODE(KeyPathSetterThunkHelper)
 NODE(KeyPathEqualsThunkHelper)
@@ -141,7 +162,12 @@ NODE(KeyPathHashThunkHelper)
 NODE(LazyProtocolWitnessTableAccessor)
 NODE(LazyProtocolWitnessTableCacheVariable)
 NODE(LocalDeclName)
+NODE(Macro)
+NODE(MacroExpansionLoc)
+NODE(MacroExpansionUniqueName)
 CONTEXT_NODE(MaterializeForSet)
+NODE(MemberAttachedMacroExpansion)
+NODE(MemberAttributeAttachedMacroExpansion)
 NODE(MergedFunction)
 NODE(Metatype)
 NODE(MetatypeRepresentation)
@@ -157,6 +183,7 @@ CONTEXT_NODE(NativeOwningMutableAddressor)
 CONTEXT_NODE(NativePinningAddressor)
 CONTEXT_NODE(NativePinningMutableAddressor)
 NODE(NominalTypeDescriptor)
+NODE(NominalTypeDescriptorRecord)
 NODE(NonObjCAttribute)
 NODE(Number)
 NODE(ObjCAsyncCompletionHandlerImpl)
@@ -169,7 +196,9 @@ CONTEXT_NODE(OwningAddressor)
 CONTEXT_NODE(OwningMutableAddressor)
 NODE(PartialApplyForwarder)
 NODE(PartialApplyObjCForwarder)
+NODE(PeerAttachedMacroExpansion)
 NODE(PostfixOperator)
+NODE(PreambleAttachedMacroExpansion)
 NODE(PrefixOperator)
 NODE(PrivateDeclName)
 NODE(PropertyDescriptor)
@@ -182,7 +211,9 @@ NODE(ProtocolConformanceRefInTypeModule)
 NODE(ProtocolConformanceRefInProtocolModule)
 NODE(ProtocolConformanceRefInOtherModule)
 NODE(ProtocolDescriptor)
+NODE(ProtocolDescriptorRecord)
 NODE(ProtocolConformanceDescriptor)
+NODE(ProtocolConformanceDescriptorRecord)
 NODE(ProtocolList)
 NODE(ProtocolListWithClass)
 NODE(ProtocolListWithAnyObject)
@@ -219,6 +250,12 @@ NODE(ThinFunctionType)
 NODE(Tuple)
 NODE(TupleElement)
 NODE(TupleElementName)
+NODE(Pack)
+NODE(SILPackDirect)
+NODE(SILPackIndirect)
+NODE(PackExpansion)
+NODE(PackElement)
+NODE(PackElementLevel)
 NODE(Type)
 CONTEXT_NODE(TypeSymbolicReference)
 CONTEXT_NODE(TypeAlias)
@@ -259,6 +296,7 @@ NODE(BaseConformanceDescriptor)
 NODE(AssociatedTypeDescriptor)
 NODE(AsyncAnnotation)
 NODE(ThrowsAnnotation)
+NODE(TypedThrowsAnnotation)
 NODE(EmptyList)
 NODE(FirstElementMarker)
 NODE(VariadicMarker)
@@ -273,6 +311,7 @@ NODE(OutlinedAssignWithTake)
 NODE(OutlinedAssignWithCopy)
 NODE(OutlinedDestroy)
 NODE(OutlinedVariable)
+NODE(OutlinedReadOnlyObject)
 NODE(AssocTypePath)
 NODE(LabelList)
 NODE(ModuleDescriptor)
@@ -289,6 +328,7 @@ NODE(AccessorFunctionReference)
 NODE(OpaqueType)
 NODE(OpaqueTypeDescriptorSymbolicReference)
 NODE(OpaqueTypeDescriptor)
+NODE(OpaqueTypeDescriptorRecord)
 NODE(OpaqueTypeDescriptorAccessor)
 NODE(OpaqueTypeDescriptorAccessorImpl)
 NODE(OpaqueTypeDescriptorAccessorKey)
@@ -320,5 +360,43 @@ NODE(IndexSubset)
 NODE(AsyncAwaitResumePartialFunction)
 NODE(AsyncSuspendResumePartialFunction)
 
+// Added in Swift 5.6
+NODE(AccessibleFunctionRecord)
+NODE(CompileTimeConst)
+
+// Added in Swift 5.7
+NODE(BackDeploymentThunk)
+NODE(BackDeploymentFallback)
+NODE(ExtendedExistentialTypeShape)
+NODE(Uniquable)
+NODE(UniqueExtendedExistentialTypeShapeSymbolicReference)
+NODE(NonUniqueExtendedExistentialTypeShapeSymbolicReference)
+NODE(SymbolicExtendedExistentialType)
+
+// Added in Swift 5.8
+NODE(MetatypeParamsRemoved)
+NODE(HasSymbolQuery)
+NODE(OpaqueReturnTypeIndex)
+NODE(OpaqueReturnTypeParent)
+
+// Addedn in Swift 6.0
+NODE(OutlinedEnumTagStore)
+NODE(OutlinedEnumProjectDataForLoad)
+NODE(OutlinedEnumGetTag)
+// Added in Swift 5.9 + 1
+NODE(AsyncRemoved)
+
+// Added in Swift 5.TBD
+NODE(ObjectiveCProtocolSymbolicReference)
+NODE(ParamLifetimeDependence)
+NODE(SelfLifetimeDependence)
+
+NODE(OutlinedInitializeWithCopyNoValueWitness)
+NODE(OutlinedAssignWithTakeNoValueWitness)
+NODE(OutlinedAssignWithCopyNoValueWitness)
+NODE(OutlinedDestroyNoValueWitness)
+
+NODE(DependentGenericInverseConformanceRequirement)
+
 #undef CONTEXT_NODE
 #undef NODE
diff --git a/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangler.h b/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangler.h
index 811e400b2..a3b62f2c0 100644
--- a/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangler.h
+++ b/symbolic-demangle/vendor/swift/include/swift/Demangling/Demangler.h
@@ -53,7 +53,8 @@ class NodeFactory {
   /// The head of the single-linked slab list.
   Slab *CurrentSlab = nullptr;
 
-  /// The size of the previously allocated slab.
+  /// The size of the previously allocated slab. This may NOT be the size of
+  /// CurrentSlab, in the case where a checkpoint has been popped.
   ///
   /// The slab size can only grow, even clear() does not reset the slab size.
   /// This initial size is good enough to fit most de-manglings.
@@ -80,6 +81,10 @@ class NodeFactory {
 #endif
 
 public:
+#ifndef NDEBUG
+  /// Enabled only by the unit tests to test the failure paths.
+  bool disableAssertionsForUnitTest = false;
+#endif
 
   NodeFactory() {
 #ifdef NODE_FACTORY_DEBUGGING
@@ -201,11 +206,42 @@ class NodeFactory {
     if (Growth < Capacity * 2)
       Growth = Capacity * 2;
     T *NewObjects = Allocate<T>(Capacity + Growth);
-    memcpy(NewObjects, Objects, OldAllocSize);
+    if (OldAllocSize)
+      memcpy(NewObjects, Objects, OldAllocSize);
     Objects = NewObjects;
     Capacity += Growth;
   }
 
+  /// Copy a std::string to memory managed by the NodeFactory, returning a
+  /// StringRef pointing to the copied string data.
+  StringRef copyString(const std::string &str) {
+    size_t stringSize = str.size() + 1; // + 1 for terminating NUL.
+
+    char *copiedString = Allocate<char>(stringSize);
+    memcpy(copiedString, str.data(), stringSize);
+    return {copiedString, str.size()};
+  }
+
+  /// A checkpoint which captures the allocator's state at any given time. A
+  /// checkpoint can be popped to free all allocations made since it was made.
+  struct Checkpoint {
+    Slab *Slab;
+    char *CurPtr;
+    char *End;
+  };
+
+  /// Create a new checkpoint with the current state of the allocator.
+  Checkpoint pushCheckpoint() const;
+
+  /// Clear all allocations made since the given checkpoint. It is
+  /// undefined behavior to pop checkpoints in an order other than the
+  /// order in which they were pushed, or to pop a checkpoint when
+  /// clear() was called after creating it. The implementation attempts
+  /// to raise a fatal error in that case, but does not guarantee it. It
+  /// is allowed to pop outer checkpoints without popping inner ones, or
+  /// to call clear() without popping existing checkpoints.
+  void popCheckpoint(Checkpoint checkpoint);
+
   /// Creates a node of kind \p K.
   NodePointer createNode(Node::Kind K);
 
@@ -343,6 +379,12 @@ enum class SymbolicReferenceKind : uint8_t {
   /// A symbolic reference to an accessor function, which can be executed in
   /// the process to get a pointer to the referenced entity.
   AccessorFunctionReference,
+  /// A symbolic reference to a unique extended existential type shape.
+  UniqueExtendedExistentialTypeShape,
+  /// A symbolic reference to a non-unique extended existential type shape.
+  NonUniqueExtendedExistentialTypeShape,
+  /// A symbolic reference to a objective C protocol ref.
+  ObjectiveCProtocol,
 };
 
 using SymbolicReferenceResolver_t = NodePointer (SymbolicReferenceKind,
@@ -373,7 +415,7 @@ class Demangler : public NodeFactory {
   std::function<SymbolicReferenceResolver_t> SymbolicReferenceResolver;
 
   bool nextIf(StringRef str) {
-    if (!Text.substr(Pos).startswith(str)) return false;
+    if (!Text.substr(Pos).starts_with(str)) return false;
     Pos += str.size();
     return true;
   }
@@ -457,8 +499,9 @@ class Demangler : public NodeFactory {
   friend DemangleInitRAII;
   
   void addSubstitution(NodePointer Nd) {
-    if (Nd)
+    if (Nd) {
       Substitutions.push_back(Nd, *this);
+    }
   }
 
   NodePointer addChild(NodePointer Parent, NodePointer Child);
@@ -510,16 +553,20 @@ class Demangler : public NodeFactory {
   NodePointer popFunctionParamLabels(NodePointer FuncType);
   NodePointer popTuple();
   NodePointer popTypeList();
+  NodePointer popPack();
+  NodePointer popSILPack();
   NodePointer popProtocol();
   NodePointer demangleBoundGenericType();
   NodePointer demangleBoundGenericArgs(NodePointer nominalType,
                                     const Vector<NodePointer> &TypeLists,
                                     size_t TypeListIdx);
   NodePointer popAnyProtocolConformanceList();
+  NodePointer popRetroactiveConformances();
   NodePointer demangleRetroactiveConformance();
   NodePointer demangleInitializer();
   NodePointer demangleImplParamConvention(Node::Kind ConvKind);
   NodePointer demangleImplResultConvention(Node::Kind ConvKind);
+  NodePointer demangleImplParameterSending();
   NodePointer demangleImplParameterResultDifferentiability();
   NodePointer demangleImplFunctionType();
   NodePointer demangleClangType();
@@ -529,6 +576,8 @@ class Demangler : public NodeFactory {
   NodePointer demangleArchetype();
   NodePointer demangleAssociatedTypeSimple(NodePointer GenericParamIdx);
   NodePointer demangleAssociatedTypeCompound(NodePointer GenericParamIdx);
+  NodePointer demangleExtendedExistentialShape(char kind);
+  NodePointer demangleSymbolicExtendedExistentialType();
 
   NodePointer popAssocTypeName();
   NodePointer popAssocTypePath();
@@ -538,6 +587,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleRetroactiveProtocolConformanceRef();
   NodePointer popAnyProtocolConformance();
   NodePointer demangleConcreteProtocolConformance();
+  NodePointer demanglePackProtocolConformance();
   NodePointer popDependentProtocolConformance();
   NodePointer demangleDependentProtocolConformanceRoot();
   NodePointer demangleDependentProtocolConformanceInherited();
@@ -566,6 +616,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleGenericRequirement();
   NodePointer demangleGenericType();
   NodePointer demangleValueWitness();
+  NodePointer demangleMacroExpansion();
 
   NodePointer demangleTypeMangling();
   NodePointer demangleSymbolicReference(unsigned char rawKind);
@@ -579,9 +630,13 @@ class Demangler : public NodeFactory {
   NodePointer demangleIndexSubset();
   NodePointer demangleDifferentiableFunctionType();
 
+  NodePointer demangleConstrainedExistentialRequirementList();
+
   bool demangleBoundGenerics(Vector<NodePointer> &TypeListList,
                              NodePointer &RetroactiveConformances);
-  
+
+  NodePointer demangleLifetimeDependenceKind(bool isSelfDependence);
+
   void dump();
 
 public:
@@ -622,7 +677,7 @@ class Demangler : public NodeFactory {
 
 /// A demangler which uses stack space for its initial memory.
 ///
-/// The \p Size paramter specifies the size of the stack space.
+/// The \p Size parameter specifies the size of the stack space.
 template <size_t Size> class StackAllocatedDemangler : public Demangler {
   char StackSpace[Size];
 
diff --git a/symbolic-demangle/vendor/swift/include/swift/Demangling/Errors.h b/symbolic-demangle/vendor/swift/include/swift/Demangling/Errors.h
new file mode 100644
index 000000000..45a0dbf05
--- /dev/null
+++ b/symbolic-demangle/vendor/swift/include/swift/Demangling/Errors.h
@@ -0,0 +1,70 @@
+//===--- Errors.h - Demangling library error handling -----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file exists because not every client links to libswiftCore (the
+// runtime), so calling swift::fatalError() or swift::warning() from within
+// the demangler is not an option.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_DEMANGLING_ERRORS_H
+#define SWIFT_DEMANGLING_ERRORS_H
+
+#include "swift/Demangling/NamespaceMacros.h"
+#include <inttypes.h>
+#include <stdarg.h>
+
+#ifndef SWIFT_FORMAT
+// SWIFT_FORMAT(fmt,first) marks a function as taking a format string argument
+// at argument `fmt`, with the first argument for the format string as `first`.
+#if __has_attribute(format)
+#define SWIFT_FORMAT(fmt, first) __attribute__((format(printf, fmt, first)))
+#else
+#define SWIFT_FORMAT(fmt, first)
+#endif
+#endif
+
+#ifndef SWIFT_VFORMAT
+// SWIFT_VFORMAT(fmt) marks a function as taking a format string argument at
+// argument `fmt`, with the arguments in a `va_list`.
+#if __has_attribute(format)
+#define SWIFT_VFORMAT(fmt) __attribute__((format(printf, fmt, 0)))
+#else
+#define SWIFT_VFORMAT(fmt)
+#endif
+#endif
+
+#ifndef SWIFT_NORETURN
+#if __has_attribute(noreturn)
+#define SWIFT_NORETURN __attribute__((__noreturn__))
+#else
+#define SWIFT_NORETURN
+#endif
+#endif
+
+namespace swift {
+namespace Demangle {
+SWIFT_BEGIN_INLINE_NAMESPACE
+
+SWIFT_NORETURN SWIFT_FORMAT(2, 3) void fatal(uint32_t flags, const char *format,
+                                             ...);
+SWIFT_FORMAT(2, 3) void warn(uint32_t flags, const char *format, ...);
+
+SWIFT_NORETURN SWIFT_VFORMAT(2) void fatalv(uint32_t flags, const char *format,
+                                            va_list val);
+SWIFT_VFORMAT(2) void warnv(uint32_t flags, const char *format, va_list val);
+
+SWIFT_END_INLINE_NAMESPACE
+} // end namespace Demangle
+} // end namespace swift
+
+#endif // SWIFT_DEMANGLING_DEMANGLE_H
diff --git a/symbolic-demangle/vendor/swift/include/swift/Demangling/ManglingMacros.h b/symbolic-demangle/vendor/swift/include/swift/Demangling/ManglingMacros.h
index 3d3b5a427..5cf386314 100644
--- a/symbolic-demangle/vendor/swift/include/swift/Demangling/ManglingMacros.h
+++ b/symbolic-demangle/vendor/swift/include/swift/Demangling/ManglingMacros.h
@@ -17,7 +17,14 @@
 #define MANGLE_AS_STRING(M) STRINGIFY_MANGLING(M)
 
 /// The mangling prefix for the new mangling.
+#if !defined(_MSC_VER) || _MSC_VER-0 >= 1926
+_Pragma("clang diagnostic push")
+_Pragma("clang diagnostic ignored \"-Wdollar-in-identifier-extension\"")
+#endif
 #define MANGLING_PREFIX $s
+#if !defined(_MSC_VER) || _MSC_VER-0 >= 1926
+_Pragma("clang diagnostic pop")
+#endif
 
 #define MANGLING_PREFIX_STR MANGLE_AS_STRING(MANGLING_PREFIX)
 
@@ -39,12 +46,16 @@
 #define NO_ARGS_MANGLING yy
 #define FUNC_TYPE_MANGLING c
 #define NOESCAPE_FUNC_TYPE_MANGLING XE
+#define DIFF_FUNC_TYPE_MANGLING Yjrc
 #define OBJC_PARTIAL_APPLY_THUNK_MANGLING Ta
 #define OPTIONAL_MANGLING(Ty) MANGLING_CONCAT2_IMPL(Ty, Sg)
 
 #define FUNCTION_MANGLING \
           MANGLING_CONCAT2(NO_ARGS_MANGLING, FUNC_TYPE_MANGLING)
 
+#define DIFF_FUNCTION_MANGLING \
+          MANGLING_CONCAT2(NO_ARGS_MANGLING, DIFF_FUNC_TYPE_MANGLING)
+
 #define NOESCAPE_FUNCTION_MANGLING \
           MANGLING_CONCAT2(NO_ARGS_MANGLING, NOESCAPE_FUNC_TYPE_MANGLING)
 
diff --git a/symbolic-demangle/vendor/swift/include/swift/Demangling/ManglingUtils.h b/symbolic-demangle/vendor/swift/include/swift/Demangling/ManglingUtils.h
index d0f750454..7c20ccd00 100644
--- a/symbolic-demangle/vendor/swift/include/swift/Demangling/ManglingUtils.h
+++ b/symbolic-demangle/vendor/swift/include/swift/Demangling/ManglingUtils.h
@@ -13,9 +13,10 @@
 #ifndef SWIFT_DEMANGLING_MANGLINGUTILS_H
 #define SWIFT_DEMANGLING_MANGLINGUTILS_H
 
-#include "llvm/ADT/StringRef.h"
 #include "swift/Demangling/NamespaceMacros.h"
 #include "swift/Demangling/Punycode.h"
+#include "llvm/ADT/StringRef.h"
+#include <optional>
 
 namespace swift {
 namespace Mangle {
@@ -99,7 +100,12 @@ char translateOperatorChar(char op);
 std::string translateOperator(StringRef Op);
 
 /// Returns the standard type kind for an 'S' substitution, e.g. 'i' for "Int".
-llvm::Optional<StringRef> getStandardTypeSubst(StringRef TypeName);
+///
+/// \param allowConcurrencyManglings When true, allows the standard
+/// substitutions for types in the _Concurrency module that were introduced in
+/// Swift 5.5.
+std::optional<StringRef> getStandardTypeSubst(StringRef TypeName,
+                                              bool allowConcurrencyManglings);
 
 /// Mangles an identifier using a generic Mangler class.
 ///
diff --git a/symbolic-demangle/vendor/swift/include/swift/Demangling/StandardTypesMangling.def b/symbolic-demangle/vendor/swift/include/swift/Demangling/StandardTypesMangling.def
index c092eb702..419555718 100644
--- a/symbolic-demangle/vendor/swift/include/swift/Demangling/StandardTypesMangling.def
+++ b/symbolic-demangle/vendor/swift/include/swift/Demangling/StandardTypesMangling.def
@@ -13,10 +13,10 @@
 /// STANDARD_TYPE(KIND, MANGLING, TYPENAME)
 ///   The 1-character MANGLING for a known TYPENAME of KIND.
 ///
-/// STANDARD_TYPE_2(KIND, MANGLING, TYPENAME)
+/// STANDARD_TYPE_CONCURRENCY(KIND, MANGLING, TYPENAME)
 ///   The 1-character MANGLING for a known TYPENAME of KIND that is in the
-///   second level of standard types, all of which are mangled with the form
-///   Sc<MANGLING>.
+///   second level of standard types in the Concurrency model, all of which are
+///   mangled with the form Sc<MANGLING>.
 ///
 /// OBJC_INTEROP_STANDARD_TYPE(KIND, MANGLING, TYPENAME)
 ///   The 1-character MANGLING for a known TYPENAME of KIND, for a type that's
@@ -79,25 +79,26 @@ STANDARD_TYPE(Protocol, y, StringProtocol)
 STANDARD_TYPE(Protocol, Z, SignedInteger)
 STANDARD_TYPE(Protocol, z, BinaryInteger)
 
-STANDARD_TYPE_2(Protocol, A, Actor)
-STANDARD_TYPE_2(Structure, C, CheckedContinuation)
-STANDARD_TYPE_2(Structure, c, UnsafeContinuation)
-STANDARD_TYPE_2(Structure, E, CancellationError)
-STANDARD_TYPE_2(Structure, e, UnownedSerialExecutor)
-STANDARD_TYPE_2(Protocol, F, Executor)
-STANDARD_TYPE_2(Protocol, f, SerialExecutor)
-STANDARD_TYPE_2(Structure, G, TaskGroup)
-STANDARD_TYPE_2(Structure, g, ThrowingTaskGroup)
-STANDARD_TYPE_2(Protocol, I, AsyncIteratorProtocol)
-STANDARD_TYPE_2(Protocol, i, AsyncSequence)
-STANDARD_TYPE_2(Structure, J, UnownedJob)
-STANDARD_TYPE_2(Class, M, MainActor)
-STANDARD_TYPE_2(Structure, P, TaskPriority)
-STANDARD_TYPE_2(Structure, S, AsyncStream)
-STANDARD_TYPE_2(Structure, s, AsyncThrowingStream)
-STANDARD_TYPE_2(Structure, T, Task)
-STANDARD_TYPE_2(Structure, t, UnsafeCurrentTask)
+STANDARD_TYPE_CONCURRENCY(Protocol, A, Actor)
+STANDARD_TYPE_CONCURRENCY(Structure, C, CheckedContinuation)
+STANDARD_TYPE_CONCURRENCY(Structure, c, UnsafeContinuation)
+STANDARD_TYPE_CONCURRENCY(Structure, E, CancellationError)
+STANDARD_TYPE_CONCURRENCY(Structure, e, UnownedSerialExecutor)
+STANDARD_TYPE_CONCURRENCY(Protocol, F, Executor)
+STANDARD_TYPE_CONCURRENCY(Protocol, f, SerialExecutor)
+STANDARD_TYPE_CONCURRENCY(Structure, G, TaskGroup)
+STANDARD_TYPE_CONCURRENCY(Structure, g, ThrowingTaskGroup)
+STANDARD_TYPE_CONCURRENCY(Protocol, h, TaskExecutor)
+STANDARD_TYPE_CONCURRENCY(Protocol, I, AsyncIteratorProtocol)
+STANDARD_TYPE_CONCURRENCY(Protocol, i, AsyncSequence)
+STANDARD_TYPE_CONCURRENCY(Structure, J, UnownedJob)
+STANDARD_TYPE_CONCURRENCY(Class, M, MainActor)
+STANDARD_TYPE_CONCURRENCY(Structure, P, TaskPriority)
+STANDARD_TYPE_CONCURRENCY(Structure, S, AsyncStream)
+STANDARD_TYPE_CONCURRENCY(Structure, s, AsyncThrowingStream)
+STANDARD_TYPE_CONCURRENCY(Structure, T, Task)
+STANDARD_TYPE_CONCURRENCY(Structure, t, UnsafeCurrentTask)
 
 #undef STANDARD_TYPE
 #undef OBJC_INTEROP_STANDARD_TYPE
-#undef STANDARD_TYPE_2
+#undef STANDARD_TYPE_CONCURRENCY
diff --git a/symbolic-demangle/vendor/swift/include/swift/Runtime/BackDeployment.h b/symbolic-demangle/vendor/swift/include/swift/Runtime/BackDeployment.h
deleted file mode 100644
index 1e6737f18..000000000
--- a/symbolic-demangle/vendor/swift/include/swift/Runtime/BackDeployment.h
+++ /dev/null
@@ -1,45 +0,0 @@
-//===--- BackDeployment.h - Support for running on older OS versions. -----===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef SWIFT_STDLIB_BACKDEPLOYMENT_H
-#define SWIFT_STDLIB_BACKDEPLOYMENT_H
-
-#if defined(__APPLE__) && defined(__MACH__)
-
-#include "swift/Runtime/Config.h"
-#include "../../../stdlib/public/SwiftShims/Visibility.h"
-
-#ifdef __cplusplus
-namespace swift { extern "C" {
-#endif
-
-#if SWIFT_CLASS_IS_SWIFT_MASK_GLOBAL_VARIABLE
-# ifndef __cplusplus
-// This file gets included from some C/ObjC files and
-// SWIFT_RUNTIME_STDLIB_SPI doesn't imply extern in C.
-extern
-# endif
-SWIFT_RUNTIME_STDLIB_SPI unsigned long long _swift_classIsSwiftMask;
-#endif
-
-/// Returns true if the current OS version, at runtime, is a back-deployment
-/// version.
-SWIFT_RUNTIME_STDLIB_INTERNAL
-int _swift_isBackDeploying();
-
-#ifdef __cplusplus
-}} // extern "C", namespace swift
-#endif
-
-#endif // defined(__APPLE__) && defined(__MACH__)
-
-#endif // SWIFT_STDLIB_BACKDEPLOYMENT_H
diff --git a/symbolic-demangle/vendor/swift/include/swift/Runtime/CMakeConfig.h b/symbolic-demangle/vendor/swift/include/swift/Runtime/CMakeConfig.h
deleted file mode 100644
index 50d94f13b..000000000
--- a/symbolic-demangle/vendor/swift/include/swift/Runtime/CMakeConfig.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// This file is processed by CMake.
-// See https://cmake.org/cmake/help/v3.0/command/configure_file.html.
-
-#ifndef SWIFT_RUNTIME_CMAKECONFIG_H
-#define SWIFT_RUNTIME_CMAKECONFIG_H
-
-#define SWIFT_BNI_OS_BUILD 0
-#define SWIFT_BNI_XCODE_BUILD 0
-
-#endif
diff --git a/symbolic-demangle/vendor/swift/include/swift/Runtime/Config.h b/symbolic-demangle/vendor/swift/include/swift/Runtime/Config.h
deleted file mode 100644
index 064263038..000000000
--- a/symbolic-demangle/vendor/swift/include/swift/Runtime/Config.h
+++ /dev/null
@@ -1,410 +0,0 @@
-//===--- Config.h - Swift Language Platform Configuration -------*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-// Definitions of common interest in Swift.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef SWIFT_RUNTIME_CONFIG_H
-#define SWIFT_RUNTIME_CONFIG_H
-
-#include "swift/Basic/Compiler.h"
-#include "swift/Runtime/CMakeConfig.h"
-
-/// SWIFT_RUNTIME_LIBRARY_VISIBILITY - If a class marked with this attribute is
-/// linked into a shared library, then the class should be private to the
-/// library and not accessible from outside it.  Can also be used to mark
-/// variables and functions, making them private to any shared library they are
-/// linked into.
-/// On PE/COFF targets, library visibility is the default, so this isn't needed.
-#if (__has_attribute(visibility) || SWIFT_GNUC_PREREQ(4, 0, 0)) &&    \
-    !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(_WIN32)
-#define SWIFT_RUNTIME_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))
-#else
-#define SWIFT_RUNTIME_LIBRARY_VISIBILITY
-#endif
-
-#define SWIFT_RUNTIME_ATTRIBUTE_NOINLINE SWIFT_ATTRIBUTE_NOINLINE
-#define SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE SWIFT_ATTRIBUTE_ALWAYS_INLINE
-#define SWIFT_RUNTIME_ATTRIBUTE_NORETURN SWIFT_ATTRIBUTE_NORETURN
-
-/// SWIFT_RUNTIME_BUILTIN_TRAP - On compilers which support it, expands to an expression
-/// which causes the program to exit abnormally.
-#if __has_builtin(__builtin_trap) || SWIFT_GNUC_PREREQ(4, 3, 0)
-# define SWIFT_RUNTIME_BUILTIN_TRAP __builtin_trap()
-#elif defined(_MSC_VER)
-// The __debugbreak intrinsic is supported by MSVC, does not require forward
-// declarations involving platform-specific typedefs (unlike RaiseException),
-// results in a call to vectored exception handlers, and encodes to a short
-// instruction that still causes the trapping behavior we want.
-# define SWIFT_RUNTIME_BUILTIN_TRAP __debugbreak()
-#else
-# define SWIFT_RUNTIME_BUILTIN_TRAP *(volatile int*)0x11 = 0
-#endif
-
-/// Does the current Swift platform support "unbridged" interoperation
-/// with Objective-C?  If so, the implementations of various types must
-/// implicitly handle Objective-C pointers.
-///
-/// Apple platforms support this by default.
-#ifndef SWIFT_OBJC_INTEROP
-#ifdef __APPLE__
-#define SWIFT_OBJC_INTEROP 1
-#else
-#define SWIFT_OBJC_INTEROP 0
-#endif
-#endif
-
-/// Does the current Swift platform allow information other than the
-/// class pointer to be stored in the isa field?  If so, when deriving
-/// the class pointer of an object, we must apply a
-/// dynamically-determined mask to the value loaded from the first
-/// field of the object.
-///
-/// According to the Objective-C ABI, this is true only for 64-bit
-/// platforms.
-#ifndef SWIFT_HAS_ISA_MASKING
-#if SWIFT_OBJC_INTEROP && __POINTER_WIDTH__ == 64
-#define SWIFT_HAS_ISA_MASKING 1
-#else
-#define SWIFT_HAS_ISA_MASKING 0
-#endif
-#endif
-
-/// Does the current Swift platform have ISA pointers which should be opaque
-/// to anyone outside the Swift runtime?  Similarly to the ISA_MASKING case
-/// above, information other than the class pointer could be contained in the
-/// ISA.
-#ifndef SWIFT_HAS_OPAQUE_ISAS
-#if defined(__arm__) && __ARM_ARCH_7K__ >= 2
-#define SWIFT_HAS_OPAQUE_ISAS 1
-#else
-#define SWIFT_HAS_OPAQUE_ISAS 0
-#endif
-#endif
-
-#if SWIFT_HAS_OPAQUE_ISAS && SWIFT_HAS_ISA_MASKING
-#error Masking ISAs are incompatible with opaque ISAs
-#endif
-
-/// Which bits in the class metadata are used to distinguish Swift classes
-/// from ObjC classes?
-#ifndef SWIFT_CLASS_IS_SWIFT_MASK
-
-// Non-Apple platforms always use 1.
-# if !defined(__APPLE__)
-#  define SWIFT_CLASS_IS_SWIFT_MASK 1ULL
-
-// Builds for Swift-in-the-OS always use 2.
-# elif SWIFT_BNI_OS_BUILD
-#  define SWIFT_CLASS_IS_SWIFT_MASK 2ULL
-
-// Builds for Xcode always use 1.
-# elif SWIFT_BNI_XCODE_BUILD
-#  define SWIFT_CLASS_IS_SWIFT_MASK 1ULL
-
-// Compatibility hook libraries cannot rely on the "is swift" bit being either
-// value, since they must work with both OS and Xcode versions of the libraries.
-// Generate a reference to a nonexistent symbol so that we get obvious linker
-// errors if we try.
-# elif SWIFT_COMPATIBILITY_LIBRARY
-extern uintptr_t __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTLY__;
-#  define SWIFT_CLASS_IS_SWIFT_MASK __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTLY__
-
-// Other builds (such as local builds on developers' computers)
-// dynamically choose the bit at runtime based on the current OS
-// version.
-# else
-#  define SWIFT_CLASS_IS_SWIFT_MASK _swift_classIsSwiftMask
-#  define SWIFT_CLASS_IS_SWIFT_MASK_GLOBAL_VARIABLE 1
-#  define SWIFT_BUILD_HAS_BACK_DEPLOYMENT 1
-#  include "BackDeployment.h"
-
-# endif
-#endif
-
-// We try to avoid global constructors in the runtime as much as possible.
-// These macros delimit allowed global ctors.
-#if __clang__
-# define SWIFT_ALLOWED_RUNTIME_GLOBAL_CTOR_BEGIN \
-    _Pragma("clang diagnostic push") \
-    _Pragma("clang diagnostic ignored \"-Wglobal-constructors\"")
-# define SWIFT_ALLOWED_RUNTIME_GLOBAL_CTOR_END \
-    _Pragma("clang diagnostic pop")
-#else
-# define SWIFT_ALLOWED_RUNTIME_GLOBAL_CTOR_BEGIN
-# define SWIFT_ALLOWED_RUNTIME_GLOBAL_CTOR_END
-#endif
-
-// Bring in visibility attribute macros
-#include "../../../stdlib/public/SwiftShims/Visibility.h"
-
-// Define mappings for calling conventions.
-
-// Annotation for specifying a calling convention of
-// a runtime function. It should be used with declarations
-// of runtime functions like this:
-// void runtime_function_name() SWIFT_CC(swift)
-#define SWIFT_CC(CC) SWIFT_CC_##CC
-
-// SWIFT_CC(c) is the C calling convention.
-#define SWIFT_CC_c
-
-// SWIFT_CC(swift) is the Swift calling convention.
-// FIXME: the next comment is false.
-// Functions outside the stdlib or runtime that include this file may be built 
-// with a compiler that doesn't support swiftcall; don't define these macros
-// in that case so any incorrect usage is caught.
-#if __has_attribute(swiftcall)
-#define SWIFT_CC_swift __attribute__((swiftcall))
-#define SWIFT_CONTEXT __attribute__((swift_context))
-#define SWIFT_ERROR_RESULT __attribute__((swift_error_result))
-#define SWIFT_INDIRECT_RESULT __attribute__((swift_indirect_result))
-#else
-#define SWIFT_CC_swift
-#define SWIFT_CONTEXT
-#define SWIFT_ERROR_RESULT
-#define SWIFT_INDIRECT_RESULT
-#endif
-
-#if __has_attribute(swift_async_context)
-#define SWIFT_ASYNC_CONTEXT __attribute__((swift_async_context))
-#else
-#define SWIFT_ASYNC_CONTEXT
-#endif
-
-// SWIFT_CC(swiftasync) is the Swift async calling convention.
-// We assume that it supports mandatory tail call elimination.
-#if __has_feature(swiftasynccc) && __has_attribute(swiftasynccall)
-#define SWIFT_CC_swiftasync __attribute__((swiftasynccall))
-#else
-#define SWIFT_CC_swiftasync SWIFT_CC_swift
-#endif
-
-// SWIFT_CC(PreserveMost) is used in the runtime implementation to prevent
-// register spills on the hot path.
-// It is not safe to use for external calls; the loader's lazy function
-// binding may not save all of the registers required for this convention.
-#if __has_attribute(preserve_most) &&                                          \
-    (defined(__aarch64__) || defined(__x86_64__))
-#define SWIFT_CC_PreserveMost __attribute__((preserve_most))
-#else
-#define SWIFT_CC_PreserveMost
-#endif
-
-// This is the DefaultCC value used by the compiler.
-// FIXME: the runtime's code does not honor DefaultCC
-// so changing this value is not sufficient.
-#define SWIFT_DEFAULT_LLVM_CC llvm::CallingConv::C
-
-// Pointer authentication.
-#if __has_feature(ptrauth_calls)
-#define SWIFT_PTRAUTH 1
-#include <ptrauth.h>
-#define __ptrauth_swift_runtime_function_entry \
-  __ptrauth(ptrauth_key_function_pointer, 1, \
-            SpecialPointerAuthDiscriminators::RuntimeFunctionEntry)
-#define __ptrauth_swift_runtime_function_entry_with_key(__key) \
-  __ptrauth(ptrauth_key_function_pointer, 1, __key)
-#define __ptrauth_swift_runtime_function_entry_strip(__fn) \
-  ptrauth_strip(__fn, ptrauth_key_function_pointer)
-#define __ptrauth_swift_type_descriptor \
-  __ptrauth(ptrauth_key_process_independent_data, 1, \
-            SpecialPointerAuthDiscriminators::TypeDescriptor)
-#define __ptrauth_swift_dynamic_replacement_key                                \
-  __ptrauth(ptrauth_key_process_independent_data, 1,                           \
-            SpecialPointerAuthDiscriminators::DynamicReplacementKey)
-#define __ptrauth_swift_job_invoke_function                                    \
-  __ptrauth(ptrauth_key_function_pointer, 1,                                   \
-            SpecialPointerAuthDiscriminators::JobInvokeFunction)
-#define __ptrauth_swift_task_resume_function                                   \
-  __ptrauth(ptrauth_key_function_pointer, 1,                                   \
-            SpecialPointerAuthDiscriminators::TaskResumeFunction)
-#define __ptrauth_swift_task_resume_context                                    \
-  __ptrauth(ptrauth_key_process_independent_data, 1,                           \
-            SpecialPointerAuthDiscriminators::TaskResumeContext)
-#define __ptrauth_swift_async_context_parent                                   \
-  __ptrauth(ptrauth_key_process_independent_data, 1,                           \
-            SpecialPointerAuthDiscriminators::AsyncContextParent)
-#define __ptrauth_swift_async_context_resume                                   \
-  __ptrauth(ptrauth_key_function_pointer, 1,                                   \
-            SpecialPointerAuthDiscriminators::AsyncContextResume)
-#define __ptrauth_swift_async_context_yield                                    \
-  __ptrauth(ptrauth_key_function_pointer, 1,                                   \
-            SpecialPointerAuthDiscriminators::AsyncContextYield)
-#define __ptrauth_swift_cancellation_notification_function                     \
-  __ptrauth(ptrauth_key_function_pointer, 1,                                   \
-            SpecialPointerAuthDiscriminators::CancellationNotificationFunction)
-#define __ptrauth_swift_escalation_notification_function                       \
-  __ptrauth(ptrauth_key_function_pointer, 1,                                   \
-            SpecialPointerAuthDiscriminators::EscalationNotificationFunction)
-#define __ptrauth_swift_dispatch_invoke_function                               \
-  __ptrauth(ptrauth_key_process_independent_code, 1,                           \
-            SpecialPointerAuthDiscriminators::DispatchInvokeFunction)
-#define __ptrauth_swift_objc_superclass                                        \
-  __ptrauth(ptrauth_key_process_independent_data, 1,                           \
-            swift::SpecialPointerAuthDiscriminators::ObjCSuperclass)
-#define swift_ptrauth_sign_opaque_read_resume_function(__fn, __buffer)         \
-  ptrauth_auth_and_resign(__fn, ptrauth_key_function_pointer, 0,               \
-                          ptrauth_key_process_independent_code,                \
-                          ptrauth_blend_discriminator(__buffer,                \
-            SpecialPointerAuthDiscriminators::OpaqueReadResumeFunction))
-#define swift_ptrauth_sign_opaque_modify_resume_function(__fn, __buffer)       \
-  ptrauth_auth_and_resign(__fn, ptrauth_key_function_pointer, 0,               \
-                          ptrauth_key_process_independent_code,                \
-                          ptrauth_blend_discriminator(__buffer,                \
-            SpecialPointerAuthDiscriminators::OpaqueModifyResumeFunction))
-#else
-#define SWIFT_PTRAUTH 0
-#define __ptrauth_swift_function_pointer(__typekey)
-#define __ptrauth_swift_class_method_pointer(__declkey)
-#define __ptrauth_swift_protocol_witness_function_pointer(__declkey)
-#define __ptrauth_swift_value_witness_function_pointer(__key)
-#define __ptrauth_swift_type_metadata_instantiation_function
-#define __ptrauth_swift_job_invoke_function
-#define __ptrauth_swift_task_resume_function
-#define __ptrauth_swift_task_resume_context
-#define __ptrauth_swift_async_context_parent
-#define __ptrauth_swift_async_context_resume
-#define __ptrauth_swift_async_context_yield
-#define __ptrauth_swift_cancellation_notification_function
-#define __ptrauth_swift_escalation_notification_function
-#define __ptrauth_swift_dispatch_invoke_function
-#define __ptrauth_swift_objc_superclass
-#define __ptrauth_swift_runtime_function_entry
-#define __ptrauth_swift_runtime_function_entry_with_key(__key)
-#define __ptrauth_swift_runtime_function_entry_strip(__fn) (__fn)
-#define __ptrauth_swift_heap_object_destructor
-#define __ptrauth_swift_type_descriptor
-#define __ptrauth_swift_dynamic_replacement_key
-#define swift_ptrauth_sign_opaque_read_resume_function(__fn, __buffer) (__fn)
-#define swift_ptrauth_sign_opaque_modify_resume_function(__fn, __buffer) (__fn)
-#endif
-
-#ifdef __cplusplus
-
-/// Copy an address-discriminated signed pointer from the source to the dest.
-template <class T>
-SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE
-static inline void swift_ptrauth_copy(T *dest, const T *src, unsigned extra) {
-#if SWIFT_PTRAUTH
-  *dest = ptrauth_auth_and_resign(*src,
-                                  ptrauth_key_function_pointer,
-                                  ptrauth_blend_discriminator(src, extra),
-                                  ptrauth_key_function_pointer,
-                                  ptrauth_blend_discriminator(dest, extra));
-#else
-  *dest = *src;
-#endif
-}
-
-/// Copy an address-discriminated signed data pointer from the source
-/// to the destination.
-template <class T>
-SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE
-static inline void swift_ptrauth_copy_data(T *dest, const T *src,
-                                           unsigned extra) {
-#if SWIFT_PTRAUTH
-  *dest = ptrauth_auth_and_resign(*src,
-                                  ptrauth_key_process_independent_data,
-                                  ptrauth_blend_discriminator(src, extra),
-                                  ptrauth_key_process_independent_data,
-                                  ptrauth_blend_discriminator(dest, extra));
-#else
-  *dest = *src;
-#endif
-}
-
-/// Copy an address-discriminated signed pointer from the source
-/// to the destination.
-template <class T>
-SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE static inline void
-swift_ptrauth_copy_code_or_data(T *dest, const T *src, unsigned extra,
-                                bool isCode) {
-  if (isCode) {
-    return swift_ptrauth_copy(dest, src, extra);
-  } else {
-    return swift_ptrauth_copy_data(dest, src, extra);
-  }
-}
-
-/// Initialize the destination with an address-discriminated signed
-/// function pointer.  This does not authenticate the source value, so be
-/// careful about how you construct it.
-template <class T>
-SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE
-static inline void swift_ptrauth_init(T *dest, T value, unsigned extra) {
-  // FIXME: assert that T is not a function-pointer type?
-#if SWIFT_PTRAUTH
-  *dest = ptrauth_sign_unauthenticated(value,
-                                  ptrauth_key_function_pointer,
-                                  ptrauth_blend_discriminator(dest, extra));
-#else
-  *dest = value;
-#endif
-}
-
-/// Initialize the destination with an address-discriminated signed
-/// data pointer.  This does not authenticate the source value, so be
-/// careful about how you construct it.
-template <class T>
-SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE
-static inline void swift_ptrauth_init_data(T *dest, T value, unsigned extra) {
-  // FIXME: assert that T is not a function-pointer type?
-#if SWIFT_PTRAUTH
-  *dest = ptrauth_sign_unauthenticated(value,
-                                  ptrauth_key_process_independent_data,
-                                  ptrauth_blend_discriminator(dest, extra));
-#else
-  *dest = value;
-#endif
-}
-
-/// Initialize the destination with an address-discriminated signed
-/// pointer.  This does not authenticate the source value, so be
-/// careful about how you construct it.
-template <class T>
-SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE static inline void
-swift_ptrauth_init_code_or_data(T *dest, T value, unsigned extra, bool isCode) {
-  if (isCode) {
-    return swift_ptrauth_init(dest, value, extra);
-  } else {
-    return swift_ptrauth_init_data(dest, value, extra);
-  }
-}
-
-template <typename T>
-SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE
-static inline T swift_auth_data_non_address(T value, unsigned extra) {
-#if SWIFT_PTRAUTH
-  return (T)ptrauth_auth_data((void *)value,
-                               ptrauth_key_process_independent_data,
-                               extra);
-#else
-  return value;
-#endif
-}
-
-template <typename T>
-SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE static inline T
-swift_auth_code(T value, unsigned extra) {
-#if SWIFT_PTRAUTH
-  return (T)ptrauth_auth_function((void *)value,
-                                  ptrauth_key_process_independent_code, extra);
-#else
-  return value;
-#endif
-}
-
-#endif
-
-#endif // SWIFT_RUNTIME_CONFIG_H
diff --git a/symbolic-demangle/vendor/swift/include/swift/Strings.h b/symbolic-demangle/vendor/swift/include/swift/Strings.h
index 409355055..8538e6931 100644
--- a/symbolic-demangle/vendor/swift/include/swift/Strings.h
+++ b/symbolic-demangle/vendor/swift/include/swift/Strings.h
@@ -24,8 +24,23 @@ constexpr static const StringLiteral STDLIB_NAME = "Swift";
 constexpr static const StringLiteral SWIFT_ONONE_SUPPORT = "SwiftOnoneSupport";
 /// The name of the Concurrency module, which supports that extension.
 constexpr static const StringLiteral SWIFT_CONCURRENCY_NAME = "_Concurrency";
+/// The name of the Concurrency Shims Clang module
+constexpr static const StringLiteral SWIFT_CONCURRENCY_SHIMS_NAME = "_SwiftConcurrencyShims";
+/// The unique ABI prefix that swift-syntax uses when it's built as part of the
+/// compiler.
+constexpr static const StringLiteral SWIFT_MODULE_ABI_NAME_PREFIX = "Compiler";
+/// The name of the Distributed module, which supports that extension.
+constexpr static const StringLiteral SWIFT_DISTRIBUTED_NAME = "Distributed";
+/// The name of the StringProcessing module, which supports that extension.
+constexpr static const StringLiteral SWIFT_STRING_PROCESSING_NAME = "_StringProcessing";
+/// The name of the Backtracing module, which supports that extension.
+constexpr static const StringLiteral SWIFT_BACKTRACING_NAME = "_Backtracing";
 /// The name of the SwiftShims module, which contains private stdlib decls.
 constexpr static const StringLiteral SWIFT_SHIMS_NAME = "SwiftShims";
+/// The name of the CxxShim module, which contains a cxx casting utility.
+constexpr static const StringLiteral CXX_SHIM_NAME = "CxxShim";
+/// The name of the Cxx module, which contains C++ interop helper protocols.
+constexpr static const StringLiteral CXX_MODULE_NAME = "Cxx";
 /// The name of the Builtin module, which contains Builtin functions.
 constexpr static const StringLiteral BUILTIN_NAME = "Builtin";
 /// The name of the clang imported header module.
@@ -50,12 +65,26 @@ constexpr static const StringLiteral SEMANTICS_PROGRAMTERMINATION_POINT =
 constexpr static const StringLiteral SEMANTICS_DEFAULT_ACTOR =
     "defaultActor";
 
+constexpr static const StringLiteral SEMANTICS_UNAVAILABLE_CODE_REACHED =
+    "unavailable_code_reached";
+
 constexpr static const StringLiteral DEFAULT_ACTOR_STORAGE_FIELD_NAME =
     "$defaultActor";
 
+constexpr static const StringLiteral NON_DEFAULT_DISTRIBUTED_ACTOR_STORAGE_FIELD_NAME =
+    "$nonDefaultDistributedActor";
+
 /// The name of the Builtin type prefix
 constexpr static const StringLiteral BUILTIN_TYPE_NAME_PREFIX = "Builtin.";
 
+/// The default SPI group name to associate with Clang SPIs.
+constexpr static const StringLiteral CLANG_MODULE_DEFAULT_SPI_GROUP_NAME =
+  "OBJC_DEFAULT_SPI_GROUP";
+
+/// The attribute name for @_spi_available
+constexpr static const StringLiteral SPI_AVAILABLE_ATTRNAME =
+  "_spi_available";
+
 /// A composition class containing a StringLiteral for the names of
 /// Swift builtins. The reason we use this is to ensure that we when
 /// necessary slice off the "Builtin." prefix from these names in a
@@ -125,12 +154,15 @@ constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_UNSAFEVALUEBUFFER =
 /// The name of the Builtin type for Job
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_JOB = {
     "Builtin.Job"};
-/// The name of the Builtin type for ExecutorRef
+/// The name of the Builtin type for SerialExecutorRef
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_EXECUTOR = {
     "Builtin.Executor"};
 /// The name of the Builtin type for DefaultActorStorage
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_DEFAULTACTORSTORAGE = {
     "Builtin.DefaultActorStorage"};
+/// The name of the Builtin type for NonDefaultDistributedActorStorage
+constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_NONDEFAULTDISTRIBUTEDACTORSTORAGE = {
+    "Builtin.NonDefaultDistributedActorStorage"};
 /// The name of the Builtin type for UnknownObject
 ///
 /// This no longer exists as an AST-accessible type, but it's still used for
@@ -146,6 +178,9 @@ constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_SILTOKEN = {
 /// The name of the Builtin type for Word
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_WORD = {
     "Builtin.Word"};
+/// The name of the Builtin type for PackIndex
+constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_PACKINDEX = {
+    "Builtin.PackIndex"};
 
 } // end namespace swift
 
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/CMakeLists.txt b/symbolic-demangle/vendor/swift/lib/Demangling/CMakeLists.txt
index 86897b52f..2b4fa3b60 100644
--- a/symbolic-demangle/vendor/swift/lib/Demangling/CMakeLists.txt
+++ b/symbolic-demangle/vendor/swift/lib/Demangling/CMakeLists.txt
@@ -1,3 +1,13 @@
+set(swift_demangling_compile_flags
+  LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING=1
+  SWIFT_SUPPORT_OLD_MANGLING=1
+  SWIFT_STDLIB_HAS_TYPE_PRINTING=1)
+
+if(SWIFT_RUNTIME_CRASH_REPORTER_CLIENT)
+  list(APPEND swift_demangling_compile_flags
+      "-DSWIFT_HAVE_CRASHREPORTERCLIENT=1")
+endif()
+
 add_swift_host_library(swiftDemangling STATIC
   Demangler.cpp
   Context.cpp
@@ -7,9 +17,11 @@ add_swift_host_library(swiftDemangling STATIC
   OldDemangler.cpp
   OldRemangler.cpp
   Punycode.cpp
-  Remangler.cpp)
+  Remangler.cpp
+  Errors.cpp
+  CrashReporter.cpp)
 target_compile_definitions(swiftDemangling PRIVATE
-  LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING=1)
+  ${swift_demangling_compile_flags})
 
 # NOTE: Runtime libraries that depend on swiftDemangling should define
 # SWIFT_INLINE_NAMESPACE to specify the identifier that will be used for an
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/Context.cpp b/symbolic-demangle/vendor/swift/lib/Demangling/Context.cpp
index 17626a3bf..69f366140 100644
--- a/symbolic-demangle/vendor/swift/lib/Demangling/Context.cpp
+++ b/symbolic-demangle/vendor/swift/lib/Demangling/Context.cpp
@@ -16,6 +16,7 @@
 
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/ManglingMacros.h"
+#include "swift/Demangling/ManglingUtils.h"
 #include "swift/Demangling/NamespaceMacros.h"
 
 namespace swift {
@@ -38,16 +39,22 @@ void Context::clear() {
 }
 
 NodePointer Context::demangleSymbolAsNode(llvm::StringRef MangledName) {
+#if SWIFT_SUPPORT_OLD_MANGLING
   if (isMangledName(MangledName)) {
     return D->demangleSymbol(MangledName);
   }
   return demangleOldSymbolAsNode(MangledName, *D);
+#else
+  return D->demangleSymbol(MangledName);
+#endif
 }
 
 NodePointer Context::demangleTypeAsNode(llvm::StringRef MangledName) {
   return D->demangleType(MangledName);
 }
 
+#if SWIFT_STDLIB_HAS_TYPE_PRINTING
+
 std::string Context::demangleSymbolAsString(llvm::StringRef MangledName,
                                             const DemangleOptions &Options) {
   NodePointer root = demangleSymbolAsNode(MangledName);
@@ -63,20 +70,22 @@ std::string Context::demangleTypeAsString(llvm::StringRef MangledName,
                                           const DemangleOptions &Options) {
   NodePointer root = demangleTypeAsNode(MangledName);
   if (!root) return MangledName.str();
-  
+
   std::string demangling = nodeToString(root, Options);
   if (demangling.empty())
     return MangledName.str();
   return demangling;
 }
 
+#endif
+
 // Removes a '.<n>' suffix from \p Name. <n> is either a number or a combination of
 // '.<other-text>.<n>'.
 // Such symbols are produced in IRGen or in LLVM optimizations.
 static llvm::StringRef stripSuffix(llvm::StringRef Name) {
   // A suffix always ends with a digit. Do this quick check to avoid scanning through the whole
   // symbol name if the symbol has no suffix (= the common case).
-  if (isdigit(Name.back())) {
+  if (swift::Mangle::isDigit(Name.back())) {
     size_t dotPos = Name.find('.');
     if (dotPos != StringRef::npos) {
       Name = Name.substr(0, dotPos);
@@ -85,18 +94,33 @@ static llvm::StringRef stripSuffix(llvm::StringRef Name) {
   return Name;
 }
 
+// Removes a 'TQ<index>' or 'TY<index>' from \p Name.
+static llvm::StringRef stripAsyncContinuation(llvm::StringRef Name) {
+  if (!Name.ends_with("_"))
+    return Name;
+
+  StringRef Stripped = Name.drop_back();
+  while (!Stripped.empty() && swift::Mangle::isDigit(Stripped.back()))
+    Stripped = Stripped.drop_back();
+
+  if (Stripped.ends_with("TQ") || Stripped.ends_with("TY"))
+    return Stripped.drop_back(2);
+
+  return Name;
+}
+
 bool Context::isThunkSymbol(llvm::StringRef MangledName) {
   if (isMangledName(MangledName)) {
-    MangledName = stripSuffix(MangledName);
+    MangledName = stripAsyncContinuation(stripSuffix(MangledName));
     // First do a quick check
-    if (MangledName.endswith("TA") ||  // partial application forwarder
-        MangledName.endswith("Ta") ||  // ObjC partial application forwarder
-        MangledName.endswith("To") ||  // swift-as-ObjC thunk
-        MangledName.endswith("TO") ||  // ObjC-as-swift thunk
-        MangledName.endswith("TR") ||  // reabstraction thunk helper function
-        MangledName.endswith("Tr") ||  // reabstraction thunk
-        MangledName.endswith("TW") ||  // protocol witness thunk
-        MangledName.endswith("fC")) {  // allocating constructor
+    if (MangledName.ends_with("TA") ||  // partial application forwarder
+        MangledName.ends_with("Ta") ||  // ObjC partial application forwarder
+        MangledName.ends_with("To") ||  // swift-as-ObjC thunk
+        MangledName.ends_with("TO") ||  // ObjC-as-swift thunk
+        MangledName.ends_with("TR") ||  // reabstraction thunk helper function
+        MangledName.ends_with("Tr") ||  // reabstraction thunk
+        MangledName.ends_with("TW") ||  // protocol witness thunk
+        MangledName.ends_with("fC")) {  // allocating constructor
 
       // To avoid false positives, we need to fully demangle the symbol.
       NodePointer Nd = D->demangleSymbol(MangledName);
@@ -121,13 +145,13 @@ bool Context::isThunkSymbol(llvm::StringRef MangledName) {
     return false;
   }
 
-  if (MangledName.startswith("_T")) {
+  if (MangledName.starts_with("_T")) {
     // Old mangling.
     StringRef Remaining = MangledName.substr(2);
-    if (Remaining.startswith("To") ||   // swift-as-ObjC thunk
-        Remaining.startswith("TO") ||   // ObjC-as-swift thunk
-        Remaining.startswith("PA_") ||  // partial application forwarder
-        Remaining.startswith("PAo_")) { // ObjC partial application forwarder
+    if (Remaining.starts_with("To") ||   // swift-as-ObjC thunk
+        Remaining.starts_with("TO") ||   // ObjC-as-swift thunk
+        Remaining.starts_with("PA_") ||  // partial application forwarder
+        Remaining.starts_with("PAo_")) { // ObjC partial application forwarder
       return true;
     }
   }
@@ -143,13 +167,16 @@ std::string Context::getThunkTarget(llvm::StringRef MangledName) {
     if (stripSuffix(MangledName) != MangledName)
       return std::string();
 
+    // Ignore any async continuation suffix
+    MangledName = stripAsyncContinuation(MangledName);
+
     // The targets of those thunks not derivable from the mangling.
-    if (MangledName.endswith("TR") ||
-        MangledName.endswith("Tr") ||
-        MangledName.endswith("TW") )
+    if (MangledName.ends_with("TR") ||
+        MangledName.ends_with("Tr") ||
+        MangledName.ends_with("TW") )
       return std::string();
 
-    if (MangledName.endswith("fC")) {
+    if (MangledName.ends_with("fC")) {
       std::string target = MangledName.str();
       target[target.size() - 1] = 'c';
       return target;
@@ -158,13 +185,13 @@ std::string Context::getThunkTarget(llvm::StringRef MangledName) {
     return MangledName.substr(0, MangledName.size() - 2).str();
   }
   // Old mangling.
-  assert(MangledName.startswith("_T"));
+  assert(MangledName.starts_with("_T"));
   StringRef Remaining = MangledName.substr(2);
-  if (Remaining.startswith("PA_"))
+  if (Remaining.starts_with("PA_"))
     return Remaining.substr(3).str();
-  if (Remaining.startswith("PAo_"))
+  if (Remaining.starts_with("PAo_"))
     return Remaining.substr(4).str();
-  assert(Remaining.startswith("To") || Remaining.startswith("TO"));
+  assert(Remaining.starts_with("To") || Remaining.starts_with("TO"));
   return std::string("_T") + Remaining.substr(2).str();
 }
 
@@ -216,7 +243,11 @@ std::string Context::getModuleName(llvm::StringRef mangledName) {
     }
     default:
       if (isSpecialized(node)) {
-        node = getUnspecialized(node, *D);
+        auto unspec = getUnspecialized(node, *D);
+        if (!unspec.isSuccess())
+          node = nullptr;
+        else
+          node = unspec.result();
         break;
       }
       if (isContext(node->getKind())) {
@@ -234,6 +265,8 @@ std::string Context::getModuleName(llvm::StringRef mangledName) {
 // Public utility functions     //
 //////////////////////////////////
 
+#if SWIFT_STDLIB_HAS_TYPE_PRINTING
+
 std::string demangleSymbolAsString(const char *MangledName,
                                    size_t MangledNameLength,
                                    const DemangleOptions &Options) {
@@ -250,6 +283,8 @@ std::string demangleTypeAsString(const char *MangledName,
                                   Options);
 }
 
+#endif
+
 SWIFT_END_INLINE_NAMESPACE
 } // namespace Demangle
 } // namespace swift
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/CrashReporter.cpp b/symbolic-demangle/vendor/swift/lib/Demangling/CrashReporter.cpp
new file mode 100644
index 000000000..ece5fb61c
--- /dev/null
+++ b/symbolic-demangle/vendor/swift/lib/Demangling/CrashReporter.cpp
@@ -0,0 +1,35 @@
+//===--- CrashReporter.cpp - Crash Reporter integration ---------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Declares gCRAnnotations.  This lets us link with other static libraries
+// that also declare gCRAnnotations, because we'll pull in their copy
+// (assuming they're linked first).
+//
+//===----------------------------------------------------------------------===//
+
+#include "CrashReporter.h"
+
+#if SWIFT_HAVE_CRASHREPORTERCLIENT
+
+// Instead of linking to CrashReporterClient.a (because it complicates the
+// build system), define the only symbol from that static archive ourselves.
+//
+// The layout of this struct is CrashReporter ABI, so there are no ABI concerns
+// here.
+extern "C" {
+SWIFT_LIBRARY_VISIBILITY
+struct crashreporter_annotations_t gCRAnnotations __attribute__((
+    __section__("__DATA," CRASHREPORTER_ANNOTATIONS_SECTION))) = {
+    CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0, 0};
+}
+
+#endif
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/CrashReporter.h b/symbolic-demangle/vendor/swift/lib/Demangling/CrashReporter.h
new file mode 100644
index 000000000..929c83dec
--- /dev/null
+++ b/symbolic-demangle/vendor/swift/lib/Demangling/CrashReporter.h
@@ -0,0 +1,50 @@
+//===--- CrashReporter.h - Crash Reporter integration -----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Declares gCRAnnotations.  This lets us link with other static libraries
+// that also declare gCRAnnotations, because we'll pull in their copy
+// (assuming they're linked first).
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_DEMANGLING_CRASHREPORTER_H
+#define SWIFT_DEMANGLING_CRASHREPORTER_H
+
+#if SWIFT_HAVE_CRASHREPORTERCLIENT
+
+// For SWIFT_LIBRARY_VISIBILITY
+#include "swift/shims/Visibility.h"
+
+#include <inttypes.h>
+
+#define CRASHREPORTER_ANNOTATIONS_VERSION 5
+#define CRASHREPORTER_ANNOTATIONS_SECTION "__crash_info"
+
+struct crashreporter_annotations_t {
+  uint64_t version;          // unsigned long
+  uint64_t message;          // char *
+  uint64_t signature_string; // char *
+  uint64_t backtrace;        // char *
+  uint64_t message2;         // char *
+  uint64_t thread;           // uint64_t
+  uint64_t dialog_mode;      // unsigned int
+  uint64_t abort_cause;      // unsigned int
+};
+
+extern "C" {
+SWIFT_LIBRARY_VISIBILITY
+extern struct crashreporter_annotations_t gCRAnnotations;
+}
+
+#endif // SWIFT_HAVE_CRASHREPORTERCLIENT
+
+#endif // SWIFT_DEMANGLING_CRASHREPORTER_H
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/Demangler.cpp b/symbolic-demangle/vendor/swift/lib/Demangling/Demangler.cpp
index adef31f5b..0d460c5e5 100644
--- a/symbolic-demangle/vendor/swift/lib/Demangling/Demangler.cpp
+++ b/symbolic-demangle/vendor/swift/lib/Demangling/Demangler.cpp
@@ -14,11 +14,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Support/Compiler.h"
 #include "swift/Demangling/Demangler.h"
-#include "swift/Demangling/ManglingUtils.h"
+#include "DemanglerAssert.h"
 #include "swift/Demangling/ManglingMacros.h"
+#include "swift/Demangling/ManglingUtils.h"
 #include "swift/Demangling/Punycode.h"
 #include "swift/Strings.h"
+#include <stdio.h>
+#include <stdlib.h>
 
 using namespace swift;
 using namespace Mangle;
@@ -41,6 +45,7 @@ static bool isDeclName(Node::Kind kind) {
     case Node::Kind::InfixOperator:
     case Node::Kind::TypeSymbolicReference:
     case Node::Kind::ProtocolSymbolicReference:
+    case Node::Kind::ObjectiveCProtocolSymbolicReference:
       return true;
     default:
       return false;
@@ -54,9 +59,11 @@ static bool isAnyGeneric(Node::Kind kind) {
     case Node::Kind::Enum:
     case Node::Kind::Protocol:
     case Node::Kind::ProtocolSymbolicReference:
+    case Node::Kind::ObjectiveCProtocolSymbolicReference:
     case Node::Kind::OtherNominalType:
     case Node::Kind::TypeAlias:
     case Node::Kind::TypeSymbolicReference:
+    case Node::Kind::BuiltinTupleType:
       return true;
     default:
       return false;
@@ -72,9 +79,12 @@ static bool isEntity(Node::Kind kind) {
 
 static bool isRequirement(Node::Kind kind) {
   switch (kind) {
+    case Node::Kind::DependentGenericParamPackMarker:
     case Node::Kind::DependentGenericSameTypeRequirement:
+    case Node::Kind::DependentGenericSameShapeRequirement:
     case Node::Kind::DependentGenericLayoutRequirement:
     case Node::Kind::DependentGenericConformanceRequirement:
+    case Node::Kind::DependentGenericInverseConformanceRequirement:
       return true;
     default:
       return false;
@@ -87,6 +97,16 @@ static bool isRequirement(Node::Kind kind) {
 // Public utility functions    //
 //////////////////////////////////
 
+void swift::Demangle::failAssert(const char *file, unsigned line,
+                                 NodePointer node, const char *expr) {
+  std::string treeStr = getNodeTreeAsString(node);
+
+  fatal(0,
+        "%s:%u: assertion failed for Node %p: %s\n"
+        "%s:%u: Node %p is:\n%s\n",
+        file, line, node, expr, file, line, node, treeStr.c_str());
+}
+
 bool swift::Demangle::isContext(Node::Kind kind) {
   switch (kind) {
 #define NODE(ID)
@@ -94,6 +114,8 @@ bool swift::Demangle::isContext(Node::Kind kind) {
     case Node::Kind::ID:
 #include "swift/Demangling/DemangleNodes.def"
       return true;
+    case Node::Kind::BuiltinTupleType:
+      return true;
     default:
       return false;
   }
@@ -117,14 +139,21 @@ bool swift::Demangle::isFunctionAttr(Node::Kind kind) {
     case Node::Kind::PartialApplyForwarder:
     case Node::Kind::PartialApplyObjCForwarder:
     case Node::Kind::OutlinedVariable:
+    case Node::Kind::OutlinedReadOnlyObject:
     case Node::Kind::OutlinedBridgedMethod:
     case Node::Kind::MergedFunction:
+    case Node::Kind::DistributedThunk:
+    case Node::Kind::DistributedAccessor:
     case Node::Kind::DynamicallyReplaceableFunctionImpl:
     case Node::Kind::DynamicallyReplaceableFunctionKey:
     case Node::Kind::DynamicallyReplaceableFunctionVar:
     case Node::Kind::AsyncFunctionPointer:
     case Node::Kind::AsyncAwaitResumePartialFunction:
     case Node::Kind::AsyncSuspendResumePartialFunction:
+    case Node::Kind::AccessibleFunctionRecord:
+    case Node::Kind::BackDeploymentThunk:
+    case Node::Kind::BackDeploymentFallback:
+    case Node::Kind::HasSymbolQuery:
       return true;
     default:
       return false;
@@ -154,11 +183,13 @@ int swift::Demangle::getManglingPrefixLength(llvm::StringRef mangledName) {
   llvm::StringRef prefixes[] = {
     /*Swift 4*/   "_T0",
     /*Swift 4.x*/ "$S", "_$S",
-    /*Swift 5+*/  "$s", "_$s"};
+    /*Swift 5+*/  "$s", "_$s",
+    /*Swift 5+ for filenames*/ "@__swiftmacro_",
+  };
 
   // Look for any of the known prefixes
   for (auto prefix : prefixes) {
-    if (mangledName.startswith(prefix))
+    if (mangledName.starts_with(prefix))
       return prefix.size();
   }
 
@@ -179,12 +210,12 @@ bool swift::Demangle::isSwiftSymbol(const char *mangledName) {
 
 bool swift::Demangle::isObjCSymbol(llvm::StringRef mangledName) {
   StringRef nameWithoutPrefix = dropSwiftManglingPrefix(mangledName);
-  return nameWithoutPrefix.startswith("So") ||
-         nameWithoutPrefix.startswith("SC");
+  return nameWithoutPrefix.starts_with("So") ||
+         nameWithoutPrefix.starts_with("SC");
 }
 
 bool swift::Demangle::isOldFunctionTypeMangling(llvm::StringRef mangledName) {
-  return mangledName.startswith("_T");
+  return mangledName.starts_with("_T");
 }
 
 llvm::StringRef swift::Demangle::dropSwiftManglingPrefix(StringRef mangledName){
@@ -250,6 +281,7 @@ static bool isProtocolNode(Demangle::NodePointer Node) {
     return isProtocolNode(Node->getChild(0));
   case Demangle::Node::Kind::Protocol:
   case Demangle::Node::Kind::ProtocolSymbolicReference:
+  case Demangle::Node::Kind::ObjectiveCProtocolSymbolicReference:
     return true;
   default:
     return false;
@@ -280,6 +312,41 @@ bool swift::Demangle::isStruct(llvm::StringRef mangledName) {
   return isStructNode(Dem.demangleType(mangledName));
 }
 
+std::string swift::Demangle::mangledNameForTypeMetadataAccessor(
+    StringRef moduleName, StringRef typeName, Node::Kind typeKind) {
+  using namespace Demangle;
+
+  //  kind=Global
+  //    kind=NominalTypeDescriptor
+  //      kind=Type
+  //        kind=Structure|Enum|Class
+  //          kind=Module, text=moduleName
+  //          kind=Identifier, text=typeName
+  Demangle::Demangler D;
+  auto *global = D.createNode(Node::Kind::Global);
+  {
+    auto *nominalDescriptor =
+        D.createNode(Node::Kind::TypeMetadataAccessFunction);
+    {
+      auto *type = D.createNode(Node::Kind::Type);
+      {
+        auto *module = D.createNode(Node::Kind::Module, moduleName);
+        auto *identifier = D.createNode(Node::Kind::Identifier, typeName);
+        auto *structNode = D.createNode(typeKind);
+        structNode->addChild(module, D);
+        structNode->addChild(identifier, D);
+        type->addChild(structNode, D);
+      }
+      nominalDescriptor->addChild(type, D);
+    }
+    global->addChild(nominalDescriptor, D);
+  }
+
+  auto mangleResult = mangleNode(global);
+  assert(mangleResult.isSuccess());
+  return mangleResult.result();
+}
+
 using namespace swift;
 using namespace Demangle;
 
@@ -287,42 +354,8 @@ using namespace Demangle;
 // Node member functions        //
 //////////////////////////////////
 
-size_t Node::getNumChildren() const {
-  switch (NodePayloadKind) {
-    case PayloadKind::OneChild: return 1;
-    case PayloadKind::TwoChildren: return 2;
-    case PayloadKind::ManyChildren: return Children.Number;
-    default: return 0;
-  }
-}
-
-Node::iterator Node::begin() const {
-  switch (NodePayloadKind) {
-    case PayloadKind::OneChild:
-    case PayloadKind::TwoChildren:
-      return &InlineChildren[0];
-    case PayloadKind::ManyChildren:
-      return Children.Nodes;
-    default:
-      return nullptr;
-  }
-}
-
-Node::iterator Node::end() const {
-  switch (NodePayloadKind) {
-    case PayloadKind::OneChild:
-      return &InlineChildren[1];
-    case PayloadKind::TwoChildren:
-      return &InlineChildren[2];
-    case PayloadKind::ManyChildren:
-      return Children.Nodes + Children.Number;
-    default:
-      return nullptr;
-  }
-}
-
 void Node::addChild(NodePointer Child, NodeFactory &Factory) {
-  assert(Child);
+  DEMANGLER_ALWAYS_ASSERT(Child, this);
   switch (NodePayloadKind) {
     case PayloadKind::None:
       InlineChildren[0] = Child;
@@ -385,6 +418,24 @@ void Node::removeChildAt(unsigned Pos) {
   }
 }
 
+void Node::replaceChild(unsigned Pos, NodePointer Child) {
+  switch (NodePayloadKind) {
+    case PayloadKind::OneChild:
+      assert(Pos == 0);
+      InlineChildren[0] = Child;
+      break;
+    case PayloadKind::TwoChildren:
+      assert(Pos < 2);
+      InlineChildren[Pos] = Child;
+      break;
+    case PayloadKind::ManyChildren:
+      Children.Nodes[Pos] = Child;
+      break;
+    default:
+      assert(false && "cannot remove child");
+  }
+}
+
 void Node::reverseChildren(size_t StartingAt) {
   assert(StartingAt <= getNumChildren());
   switch (NodePayloadKind) {
@@ -401,6 +452,20 @@ void Node::reverseChildren(size_t StartingAt) {
   }
 }
 
+Node* Node::findByKind(Node::Kind kind, int maxDepth) {
+  if (getKind() == kind)
+    return this;
+
+  if (maxDepth <= 0)
+    return nullptr;
+
+  for (auto node : *this)
+    if (auto matchingChild = node->findByKind(kind, maxDepth - 1))
+      return matchingChild;
+
+  return nullptr;
+}
+
 //////////////////////////////////
 // NodeFactory member functions //
 //////////////////////////////////
@@ -430,13 +495,91 @@ void NodeFactory::clear() {
     // cycles.
     CurrentSlab->Previous = nullptr;
     CurPtr = (char *)(CurrentSlab + 1);
-    assert(End == CurPtr + SlabSize);
 #ifdef NODE_FACTORY_DEBUGGING
     allocatedMemory = 0;
 #endif
   }
 }
 
+NodeFactory::Checkpoint NodeFactory::pushCheckpoint() const {
+  return {CurrentSlab, CurPtr, End};
+}
+
+void NodeFactory::popCheckpoint(NodeFactory::Checkpoint checkpoint) {
+  if (checkpoint.Slab == CurrentSlab) {
+    if (checkpoint.CurPtr > CurPtr) {
+      fatal(0,
+            "Popping checkpoint {%p, %p, %p} that is after the current "
+            "pointer.\n",
+            checkpoint.Slab, checkpoint.CurPtr, checkpoint.End);
+    }
+    if (checkpoint.End != End) {
+      fatal(0,
+            "Popping checkpoint {%p, %p, %p} with End that does not match "
+            "current End %p.\n",
+            checkpoint.Slab, checkpoint.CurPtr, checkpoint.End, End);
+    }
+#ifndef NDEBUG
+    // Scribble the newly freed area.
+    memset(checkpoint.CurPtr, 0xaa, CurPtr - checkpoint.CurPtr);
+#endif
+    CurPtr = checkpoint.CurPtr;
+  } else {
+    // We may want to keep using the current slab rather than destroying
+    // it, since over time this allows us to converge on a steady state
+    // with no allocation activity (see the comment above in
+    // NodeFactory::clear). Keep using the current slab if the free space in the
+    // checkpoint's slab is less than 1/16th of the current slab's space. We
+    // won't repeatedly allocate and deallocate the current slab. The size
+    // doubles each time so we'll quickly pass the threshold.
+    Slab *savedSlab = nullptr;
+    if (CurrentSlab) {
+      size_t checkpointSlabFreeSpace = checkpoint.End - checkpoint.CurPtr;
+      size_t currentSlabSize = End - (char *)(CurrentSlab + 1);
+      if (currentSlabSize / 16 > checkpointSlabFreeSpace) {
+        savedSlab = CurrentSlab;
+        CurrentSlab = CurrentSlab->Previous;
+        // No need to save End, as it will still be in place later.
+      }
+    }
+
+    // Free all slabs (possibly except the one we saved) until we find the end
+    // or we find the checkpoint.
+    while (CurrentSlab && checkpoint.Slab != CurrentSlab) {
+      auto Slab = CurrentSlab;
+      CurrentSlab = CurrentSlab->Previous;
+      free(Slab);
+    }
+
+    // If we ran to the end and the checkpoint actually has a slab pointer, then
+    // the checkpoint is invalid.
+    if (!CurrentSlab && checkpoint.Slab) {
+      fatal(0,
+            "Popping checkpoint {%p, %p, %p} with slab that is not within "
+            "the allocator's slab chain.\n",
+            checkpoint.Slab, checkpoint.CurPtr, checkpoint.End);
+    }
+
+    if (savedSlab) {
+      // Reinstall the saved slab.
+      savedSlab->Previous = CurrentSlab;
+      CurrentSlab = savedSlab;
+      CurPtr = (char *)(CurrentSlab + 1);
+      // End is still valid from before.
+    } else {
+      // Set CurPtr and End to match the checkpoint's position.
+      CurPtr = checkpoint.CurPtr;
+      End = checkpoint.End;
+    }
+
+#ifndef NDEBUG
+    // Scribble the now freed end of the slab.
+    if (CurPtr)
+      memset(CurPtr, 0xaa, End - CurPtr);
+#endif
+  }
+}
+
 NodePointer NodeFactory::createNode(Node::Kind K) {
   return new (Allocate<Node>()) Node(K);
 }
@@ -458,6 +601,58 @@ NodePointer NodeFactory::createNode(Node::Kind K, const char *Text) {
 int NodeFactory::nestingLevel = 0;
 #endif
 
+// Fast integer formatting
+namespace {
+
+// Format an unsigned integer into a buffer
+template <typename U,
+          typename std::enable_if<std::is_unsigned<U>::value, bool>::type = true>
+size_t int2str(U n, char *buf) {
+  // The easy case is zero
+  if (n == 0) {
+    *buf++ = '0';
+    *buf++ = '\0';
+    return 1;
+  }
+
+  // Do the digits one a time (for really high speed we could do these in
+  // chunks, but that's probably not necessary here.)
+  char *ptr = buf;
+  while (n) {
+    char digit = '0' + (n % 10);
+    n /= 10;
+    *ptr++ = digit;
+  }
+  size_t len = ptr - buf;
+
+  // Terminate the string
+  *ptr = '\0';
+
+  // Now reverse the digits
+  while (buf < ptr) {
+    char tmp = *--ptr;
+    *ptr = *buf;
+    *buf++ = tmp;
+  }
+
+  return len;
+}
+
+// Deal with negative numbers
+template <typename S,
+          typename std::enable_if<std::is_signed<S>::value, bool>::type = true>
+size_t int2str(S n, char *buf) {
+  using U = typename std::make_unsigned<S>::type;
+
+  if (n < 0) {
+    *buf++ = '-';
+    return int2str(static_cast<U>(-n), buf);
+  }
+  return int2str(static_cast<U>(n), buf);
+}
+
+} // namespace
+
 //////////////////////////////////
 // CharVector member functions  //
 //////////////////////////////////
@@ -474,7 +669,7 @@ void CharVector::append(int Number, NodeFactory &Factory) {
   const int MaxIntPrintSize = 11;
   if (NumElems + MaxIntPrintSize > Capacity)
     Factory.Reallocate(Elems, Capacity, /*Growth*/ MaxIntPrintSize);
-  int Length = snprintf(Elems + NumElems, MaxIntPrintSize, "%d", Number);
+  int Length = int2str(Number, Elems + NumElems);
   assert(Length > 0 && Length < MaxIntPrintSize);
   NumElems += Length;
 }
@@ -483,7 +678,7 @@ void CharVector::append(unsigned long long Number, NodeFactory &Factory) {
   const int MaxPrintSize = 21;
   if (NumElems + MaxPrintSize > Capacity)
     Factory.Reallocate(Elems, Capacity, /*Growth*/ MaxPrintSize);
-  int Length = snprintf(Elems + NumElems, MaxPrintSize, "%llu", Number);
+  int Length = int2str(Number, Elems + NumElems);
   assert(Length > 0 && Length < MaxPrintSize);
   NumElems += Length;
 }
@@ -527,14 +722,15 @@ Demangler::DemangleInitRAII::~DemangleInitRAII() {
 }
 
 NodePointer Demangler::demangleSymbol(StringRef MangledName,
-        std::function<SymbolicReferenceResolver_t> SymbolicReferenceResolver) {
-  DemangleInitRAII state(*this, MangledName,
-                         std::move(SymbolicReferenceResolver));
+        std::function<SymbolicReferenceResolver_t> Resolver) {
+  DemangleInitRAII state(*this, MangledName, std::move(Resolver));
 
+#if SWIFT_SUPPORT_OLD_MANGLING
   // Demangle old-style class and protocol names, which are still used in the
   // ObjC metadata.
   if (nextIf("_Tt"))
     return demangleOldSymbolAsNode(Text, *this);
+#endif
 
   unsigned PrefixLength = getManglingPrefixLength(MangledName);
   if (PrefixLength == 0)
@@ -574,9 +770,8 @@ NodePointer Demangler::demangleSymbol(StringRef MangledName,
 }
 
 NodePointer Demangler::demangleType(StringRef MangledName,
-        std::function<SymbolicReferenceResolver_t> SymbolicReferenceResolver) {
-  DemangleInitRAII state(*this, MangledName,
-                         std::move(SymbolicReferenceResolver));
+        std::function<SymbolicReferenceResolver_t> Resolver) {
+  DemangleInitRAII state(*this, MangledName, std::move(Resolver));
 
   parseAndPushNodes();
 
@@ -695,18 +890,37 @@ NodePointer Demangler::demangleSymbolicReference(unsigned char rawKind) {
   SymbolicReferenceKind kind;
   Directness direct;
   switch (rawKind) {
-  case 1:
+  case 0x01:
     kind = SymbolicReferenceKind::Context;
     direct = Directness::Direct;
     break;
-  case 2:
+  case 0x02:
     kind = SymbolicReferenceKind::Context;
     direct = Directness::Indirect;
     break;
-  case 9:
+  case 0x09:
     kind = SymbolicReferenceKind::AccessorFunctionReference;
     direct = Directness::Direct;
     break;
+  case 0x0a:
+    kind = SymbolicReferenceKind::UniqueExtendedExistentialTypeShape;
+    direct = Directness::Direct;
+    break;
+  case 0x0b:
+    kind = SymbolicReferenceKind::NonUniqueExtendedExistentialTypeShape;
+    direct = Directness::Direct;
+    break;
+  case 0x0c:
+    kind = SymbolicReferenceKind::ObjectiveCProtocol;
+    direct = Directness::Direct;
+    break;
+  // These are all currently reserved but unused.
+  case 0x03: // direct to protocol conformance descriptor
+  case 0x04: // indirect to protocol conformance descriptor
+  case 0x05: // direct to associated conformance descriptor
+  case 0x06: // indirect to associated conformance descriptor
+  case 0x07: // direct to associated conformance access function
+  case 0x08: // indirect to associated conformance access function
   default:
     return nullptr;
   }
@@ -716,15 +930,17 @@ NodePointer Demangler::demangleSymbolicReference(unsigned char rawKind) {
   NodePointer resolved = nullptr;
   if (SymbolicReferenceResolver)
     resolved = SymbolicReferenceResolver(kind, direct, value, at);
-    
+
   // With no resolver, or a resolver that failed, refuse to demangle further.
   if (!resolved)
     return nullptr;
   
   // Types register as substitutions even when symbolically referenced.
   // OOPS: Except for opaque type references!
-  if (kind == SymbolicReferenceKind::Context &&
-      resolved->getKind() != Node::Kind::OpaqueTypeDescriptorSymbolicReference &&
+  if ((kind == SymbolicReferenceKind::Context ||
+       kind == SymbolicReferenceKind::ObjectiveCProtocol) &&
+      resolved->getKind() !=
+          Node::Kind::OpaqueTypeDescriptorSymbolicReference &&
       resolved->getKind() != Node::Kind::OpaqueReturnTypeOf)
     addSubstitution(resolved);
   return resolved;
@@ -734,6 +950,8 @@ NodePointer Demangler::demangleTypeAnnotation() {
   switch (char c2 = nextChar()) {
   case 'a':
     return createNode(Node::Kind::AsyncAnnotation);
+  case 'A':
+    return createNode(Node::Kind::IsolatedAnyFunctionType);
   case 'b':
     return createNode(Node::Kind::ConcurrentFunctionType);
   case 'c':
@@ -747,6 +965,20 @@ NodePointer Demangler::demangleTypeAnnotation() {
   case 'k':
     return createType(
         createWithChild(Node::Kind::NoDerivative, popTypeAndGetChild()));
+  case 'K':
+    return createWithChild(Node::Kind::TypedThrowsAnnotation, popTypeAndGetChild());
+  case 't':
+    return createType(
+        createWithChild(Node::Kind::CompileTimeConst, popTypeAndGetChild()));
+  case 'T':
+    return createNode(Node::Kind::SendingResultFunctionType);
+  case 'u':
+    return createType(
+        createWithChild(Node::Kind::Sending, popTypeAndGetChild()));
+  case 'l':
+    return demangleLifetimeDependenceKind(/*isSelfDependence*/ false);
+  case 'L':
+    return demangleLifetimeDependenceKind(/*isSelfDependence*/ true);
   default:
     return nullptr;
   }
@@ -782,6 +1014,21 @@ NodePointer Demangler::demangleOperator() {
       case 'p':
         return createWithChild(
             Node::Kind::ProtocolConformanceRefInProtocolModule, popProtocol());
+      case 'X': return demanglePackProtocolConformance();
+
+      // Runtime records (type/protocol/conformance/function)
+      case 'c':
+        return createWithChild(Node::Kind::ProtocolConformanceDescriptorRecord,
+                               popProtocolConformance());
+      case 'n':
+        return createWithPoppedType(Node::Kind::NominalTypeDescriptorRecord);
+      case 'o': // XXX
+        return createWithChild(Node::Kind::OpaqueTypeDescriptorRecord, popNode());
+      case 'r':
+        return createWithChild(Node::Kind::ProtocolDescriptorRecord, popProtocol());
+      case 'F':
+        return createNode(Node::Kind::AccessibleFunctionRecord);
+
       default:
         pushBack();
         pushBack();
@@ -975,7 +1222,7 @@ NodePointer Demangler::createStandardSubstitution(
     return createSwiftType(Node::Kind::KIND, #TYPENAME);          \
   }
 
-#define STANDARD_TYPE_2(KIND, MANGLING, TYPENAME)                   \
+#define STANDARD_TYPE_CONCURRENCY(KIND, MANGLING, TYPENAME)                   \
   if (SecondLevel && Subst == #MANGLING[0]) {                    \
     return createSwiftType(Node::Kind::KIND, #TYPENAME);          \
   }
@@ -1194,7 +1441,7 @@ NodePointer Demangler::demangleBuiltinType() {
         return nullptr;
       NodePointer EltType = popTypeAndGetChild();
       if (!EltType || EltType->getKind() != Node::Kind::BuiltinTypeName ||
-          !EltType->getText().startswith(BUILTIN_TYPE_NAME_PREFIX))
+          !EltType->getText().starts_with(BUILTIN_TYPE_NAME_PREFIX))
         return nullptr;
       CharVector name;
       name.append(BUILTIN_TYPE_NAME_VEC, *this);
@@ -1225,6 +1472,10 @@ NodePointer Demangler::demangleBuiltinType() {
       Ty = createNode(Node::Kind::BuiltinTypeName,
                                BUILTIN_TYPE_NAME_DEFAULTACTORSTORAGE);
       break;
+    case 'd':
+      Ty = createNode(Node::Kind::BuiltinTypeName,
+                               BUILTIN_TYPE_NAME_NONDEFAULTDISTRIBUTEDACTORSTORAGE);
+      break;
     case 'c':
       Ty = createNode(Node::Kind::BuiltinTypeName,
                                BUILTIN_TYPE_NAME_RAWUNSAFECONTINUATION);
@@ -1236,6 +1487,13 @@ NodePointer Demangler::demangleBuiltinType() {
       Ty = createNode(Node::Kind::BuiltinTypeName,
                                BUILTIN_TYPE_NAME_WORD);
       break;
+    case 'P':
+      Ty = createNode(Node::Kind::BuiltinTypeName,
+                               BUILTIN_TYPE_NAME_PACKINDEX);
+      break;
+    case 'T':
+      Ty = createNode(Node::Kind::BuiltinTupleType);
+      break;
     default:
       return nullptr;
   }
@@ -1260,6 +1518,39 @@ NodePointer Demangler::demangleExtensionContext() {
   return Ext;
 }
 
+/// Associate any \c OpaqueReturnType nodes with the declaration whose opaque
+/// return type they refer back to.
+static Node *setParentForOpaqueReturnTypeNodes(Demangler &D,
+                                              Node *parent,
+                                              Node *visitedNode) {
+  if (!parent || !visitedNode)
+    return nullptr;
+  if (visitedNode->getKind() == Node::Kind::OpaqueReturnType) {
+    // If this node is not already parented, parent it.
+    if (visitedNode->hasChildren()
+        && visitedNode->getLastChild()->getKind() == Node::Kind::OpaqueReturnTypeParent) {
+      return parent;
+    }
+    visitedNode->addChild(D.createNode(Node::Kind::OpaqueReturnTypeParent,
+                                       (Node::IndexType)parent), D);
+    return parent;
+  }
+  
+  // If this node is one that may in turn define its own opaque return type,
+  // stop recursion, since any opaque return type nodes underneath would refer
+  // to the nested declaration rather than the one we're looking at.
+  if (visitedNode->getKind() == Node::Kind::Function
+      || visitedNode->getKind() == Node::Kind::Variable
+      || visitedNode->getKind() == Node::Kind::Subscript) {
+    return parent;
+  }
+  
+  for (size_t i = 0, e = visitedNode->getNumChildren(); i < e; ++i) {
+    setParentForOpaqueReturnTypeNodes(D, parent, visitedNode->getChild(i));
+  }
+  return parent;
+}
+
 NodePointer Demangler::demanglePlainFunction() {
   NodePointer GenSig = popNode(Node::Kind::DependentGenericSignature);
   NodePointer Type = popFunctionType(Node::Kind::FunctionType);
@@ -1273,10 +1564,12 @@ NodePointer Demangler::demanglePlainFunction() {
   auto Name = popNode(isDeclName);
   auto Ctx = popContext();
 
-  if (LabelList)
-    return createWithChildren(Node::Kind::Function, Ctx, Name, LabelList, Type);
-
-  return createWithChildren(Node::Kind::Function, Ctx, Name, Type);
+  NodePointer result = LabelList
+    ? createWithChildren(Node::Kind::Function, Ctx, Name, LabelList, Type)
+    : createWithChildren(Node::Kind::Function, Ctx, Name, Type);
+    
+  result = setParentForOpaqueReturnTypeNodes(*this, result, Type);
+  return result;
 }
 
 NodePointer Demangler::popFunctionType(Node::Kind kind, bool hasClangType) {
@@ -1286,9 +1579,15 @@ NodePointer Demangler::popFunctionType(Node::Kind kind, bool hasClangType) {
     ClangType = demangleClangType();
   }
   addChild(FuncType, ClangType);
+  addChild(FuncType, popNode(Node::Kind::SelfLifetimeDependence));
   addChild(FuncType, popNode(Node::Kind::GlobalActorFunctionType));
+  addChild(FuncType, popNode(Node::Kind::IsolatedAnyFunctionType));
+  addChild(FuncType, popNode(Node::Kind::SendingResultFunctionType));
   addChild(FuncType, popNode(Node::Kind::DifferentiableFunctionType));
-  addChild(FuncType, popNode(Node::Kind::ThrowsAnnotation));
+  addChild(FuncType, popNode([](Node::Kind kind) {
+    return kind == Node::Kind::ThrowsAnnotation ||
+      kind == Node::Kind::TypedThrowsAnnotation;
+  }));
   addChild(FuncType, popNode(Node::Kind::ConcurrentFunctionType));
   addChild(FuncType, popNode(Node::Kind::AsyncAnnotation));
 
@@ -1323,14 +1622,25 @@ NodePointer Demangler::popFunctionParamLabels(NodePointer Type) {
     return nullptr;
 
   unsigned FirstChildIdx = 0;
+  if (FuncType->getChild(FirstChildIdx)->getKind() ==
+      Node::Kind::SelfLifetimeDependence)
+    ++FirstChildIdx;
   if (FuncType->getChild(FirstChildIdx)->getKind()
         == Node::Kind::GlobalActorFunctionType)
     ++FirstChildIdx;
+  if (FuncType->getChild(FirstChildIdx)->getKind()
+        == Node::Kind::IsolatedAnyFunctionType)
+    ++FirstChildIdx;
+  if (FuncType->getChild(FirstChildIdx)->getKind() ==
+      Node::Kind::SendingResultFunctionType)
+    ++FirstChildIdx;
   if (FuncType->getChild(FirstChildIdx)->getKind()
         == Node::Kind::DifferentiableFunctionType)
     ++FirstChildIdx;
   if (FuncType->getChild(FirstChildIdx)->getKind()
-        == Node::Kind::ThrowsAnnotation)
+        == Node::Kind::ThrowsAnnotation ||
+      FuncType->getChild(FirstChildIdx)->getKind()
+        == Node::Kind::TypedThrowsAnnotation)
     ++FirstChildIdx;
   if (FuncType->getChild(FirstChildIdx)->getKind()
         == Node::Kind::ConcurrentFunctionType)
@@ -1338,6 +1648,9 @@ NodePointer Demangler::popFunctionParamLabels(NodePointer Type) {
   if (FuncType->getChild(FirstChildIdx)->getKind()
         == Node::Kind::AsyncAnnotation)
     ++FirstChildIdx;
+  if (FuncType->getChild(FirstChildIdx)->getKind() ==
+      Node::Kind::ParamLifetimeDependence)
+    ++FirstChildIdx;
   auto ParameterType = FuncType->getChild(FirstChildIdx);
 
   assert(ParameterType->getKind() == Node::Kind::ArgumentTuple);
@@ -1439,6 +1752,56 @@ NodePointer Demangler::popTuple() {
   return createType(Root);
 }
 
+NodePointer Demangler::popPack() {
+  NodePointer Root = createNode(Node::Kind::Pack);
+
+  if (!popNode(Node::Kind::EmptyList)) {
+    bool firstElem = false;
+    do {
+      firstElem = (popNode(Node::Kind::FirstElementMarker) != nullptr);
+      NodePointer Ty = popNode(Node::Kind::Type);
+      if (!Ty)
+        return nullptr;
+      Root->addChild(Ty, *this);
+    } while (!firstElem);
+
+    Root->reverseChildren();
+  }
+  return createType(Root);
+}
+
+NodePointer Demangler::popSILPack() {
+  NodePointer Root;
+
+  switch (nextChar()) {
+  case 'd':
+    Root = createNode(Node::Kind::SILPackDirect);
+    break;
+
+  case 'i':
+    Root = createNode(Node::Kind::SILPackIndirect);
+    break;
+
+  default:
+    return nullptr;
+  }
+
+  if (!popNode(Node::Kind::EmptyList)) {
+    bool firstElem = false;
+    do {
+      firstElem = (popNode(Node::Kind::FirstElementMarker) != nullptr);
+      NodePointer Ty = popNode(Node::Kind::Type);
+      if (!Ty)
+        return nullptr;
+      Root->addChild(Ty, *this);
+    } while (!firstElem);
+
+    Root->reverseChildren();
+  }
+
+  return createType(Root);
+}
+
 NodePointer Demangler::popTypeList() {
   NodePointer Root = createNode(Node::Kind::TypeList);
 
@@ -1470,6 +1833,9 @@ NodePointer Demangler::popProtocol() {
   
   if (NodePointer SymbolicRef = popNode(Node::Kind::ProtocolSymbolicReference)){
     return SymbolicRef;
+  } else if (NodePointer SymbolicRef =
+                 popNode(Node::Kind::ObjectiveCProtocolSymbolicReference)) {
+    return SymbolicRef;
   }
 
   NodePointer Name = popNode(isDeclName);
@@ -1500,6 +1866,7 @@ NodePointer Demangler::popAnyProtocolConformance() {
   return popNode([](Node::Kind kind) {
     switch (kind) {
     case Node::Kind::ConcreteProtocolConformance:
+    case Node::Kind::PackProtocolConformance:
     case Node::Kind::DependentProtocolConformanceRoot:
     case Node::Kind::DependentProtocolConformanceInherited:
     case Node::Kind::DependentProtocolConformanceAssociated:
@@ -1537,6 +1904,13 @@ NodePointer Demangler::demangleConcreteProtocolConformance() {
                             type, conformanceRef, conditionalConformanceList);
 }
 
+NodePointer Demangler::demanglePackProtocolConformance() {
+  NodePointer patternConformanceList = popAnyProtocolConformanceList();
+
+  return createWithChild(Node::Kind::PackProtocolConformance,
+                         patternConformanceList);
+}
+
 NodePointer Demangler::popDependentProtocolConformance() {
   return popNode([](Node::Kind kind) {
     switch (kind) {
@@ -1601,17 +1975,21 @@ NodePointer Demangler::demangleRetroactiveConformance() {
   return createWithChildren(Node::Kind::RetroactiveConformance, index, conformance);
 }
 
+NodePointer Demangler::popRetroactiveConformances() {
+  NodePointer conformancesNode = nullptr;
+  while (auto conformance = popNode(Node::Kind::RetroactiveConformance)) {
+    if (!conformancesNode)
+      conformancesNode = createNode(Node::Kind::TypeList);
+    conformancesNode->addChild(conformance, *this);
+  }
+  if (conformancesNode)
+    conformancesNode->reverseChildren();
+  return conformancesNode;
+}
+
 bool Demangler::demangleBoundGenerics(Vector<NodePointer> &TypeListList,
                                       NodePointer &RetroactiveConformances) {
-  RetroactiveConformances = nullptr;
-  while (auto RetroactiveConformance =
-         popNode(Node::Kind::RetroactiveConformance)) {
-    if (!RetroactiveConformances)
-      RetroactiveConformances = createNode(Node::Kind::TypeList);
-    RetroactiveConformances->addChild(RetroactiveConformance, *this);
-  }
-  if (RetroactiveConformances)
-    RetroactiveConformances->reverseChildren();
+  RetroactiveConformances = popRetroactiveConformances();
   
   for (;;) {
     NodePointer TList = createNode(Node::Kind::TypeList);
@@ -1658,6 +2036,7 @@ bool Demangle::nodeConsumesGenericArgs(Node *node) {
     case Node::Kind::Initializer:
     case Node::Kind::PropertyWrapperBackingInitializer:
     case Node::Kind::PropertyWrapperInitFromProjectedValue:
+    case Node::Kind::Static:
       return false;
     default:
       return true;
@@ -1785,6 +2164,9 @@ NodePointer Demangler::demangleImplParamConvention(Node::Kind ConvKind) {
     case 'g': attr = "@guaranteed"; break;
     case 'e': attr = "@deallocating"; break;
     case 'y': attr = "@unowned"; break;
+    case 'v': attr = "@pack_owned"; break;
+    case 'p': attr = "@pack_guaranteed"; break;
+    case 'm': attr = "@pack_inout"; break;
     default:
       pushBack();
       return nullptr;
@@ -1801,6 +2183,7 @@ NodePointer Demangler::demangleImplResultConvention(Node::Kind ConvKind) {
     case 'd': attr = "@unowned"; break;
     case 'u': attr = "@unowned_inner_pointer"; break;
     case 'a': attr = "@autoreleased"; break;
+    case 'k': attr = "@pack_out"; break;
     default:
       pushBack();
       return nullptr;
@@ -1809,6 +2192,14 @@ NodePointer Demangler::demangleImplResultConvention(Node::Kind ConvKind) {
                          createNode(Node::Kind::ImplConvention, attr));
 }
 
+NodePointer Demangler::demangleImplParameterSending() {
+  // Empty string represents default differentiability.
+  if (!nextIf('T'))
+    return nullptr;
+  const char *attr = "sending";
+  return createNode(Node::Kind::ImplParameterSending, attr);
+}
+
 NodePointer Demangler::demangleImplParameterResultDifferentiability() {
   // Empty string represents default differentiability.
   const char *attr = "";
@@ -1856,7 +2247,8 @@ NodePointer Demangler::demangleImplFunctionType() {
       return nullptr;
 
     auto subsNode = createNode(Node::Kind::ImplInvocationSubstitutions);
-    assert(Substitutions.size() == 1);
+    if (Substitutions.size() != 1)
+      return nullptr;
     subsNode->addChild(Substitutions[0], *this);
     if (SubstitutionRetroConformances)
       subsNode->addChild(SubstitutionRetroConformances, *this);
@@ -1870,6 +2262,9 @@ NodePointer Demangler::demangleImplFunctionType() {
   if (nextIf('e'))
     type->addChild(createNode(Node::Kind::ImplEscaping), *this);
 
+  if (nextIf('A'))
+    type->addChild(createNode(Node::Kind::ImplErasedIsolation), *this);
+
   switch ((MangledDifferentiabilityKind)peekChar()) {
   case MangledDifferentiabilityKind::Normal:  // 'd'
   case MangledDifferentiabilityKind::Linear:  // 'l'
@@ -1918,7 +2313,7 @@ NodePointer Demangler::demangleImplFunctionType() {
     FAttrNode->addChild(
         createNode(Node::Kind::ImplFunctionConventionName, FConv), *this);
     if (hasClangType)
-      FAttrNode->addChild(demangleClangType(), *this);
+      addChild(FAttrNode, demangleClangType());
     type->addChild(FAttrNode, *this);
   }
 
@@ -1948,8 +2343,15 @@ NodePointer Demangler::demangleImplFunctionType() {
     type = addChild(type, Param);
     if (NodePointer Diff = demangleImplParameterResultDifferentiability())
       Param = addChild(Param, Diff);
+    if (auto Sending = demangleImplParameterSending())
+      Param = addChild(Param, Sending);
     ++NumTypesToAdd;
   }
+
+  if (nextIf('T')) {
+    type->addChild(createNode(Node::Kind::ImplSendingResult), *this);
+  }
+
   while (NodePointer Result = demangleImplResultConvention(
                                                     Node::Kind::ImplResult)) {
     type = addChild(type, Result);
@@ -2058,6 +2460,8 @@ NodePointer Demangler::demangleMetatype() {
       return createWithChild(Node::Kind::ProtocolDescriptor, popProtocol());
     case 'P':
       return createWithPoppedType(Node::Kind::GenericTypeMetadataPattern);
+    case 'q':
+      return createWithChild(Node::Kind::Uniquable, popNode());
     case 'Q':
       return createWithChild(Node::Kind::OpaqueTypeDescriptor, popNode());
     case 'r':
@@ -2173,6 +2577,13 @@ NodePointer Demangler::demangleArchetype() {
   case 'r': {
     return createType(createNode(Node::Kind::OpaqueReturnType));
   }
+  case 'R': {
+    int ordinal = demangleIndex();
+    if (ordinal < 0)
+      return NULL;
+    return createType(createWithChild(Node::Kind::OpaqueReturnType,
+                      createNode(Node::Kind::OpaqueReturnTypeIndex, ordinal)));
+  }
 
   case 'x': {
     NodePointer T = demangleAssociatedTypeSimple(nullptr);
@@ -2210,6 +2621,28 @@ NodePointer Demangler::demangleArchetype() {
     addSubstitution(T);
     return T;
   }
+  case 'p': {
+    NodePointer CountTy = popTypeAndGetChild();
+    NodePointer PatternTy = popTypeAndGetChild();
+    NodePointer PackExpansionTy = createType(
+          createWithChildren(Node::Kind::PackExpansion, PatternTy, CountTy));
+    return PackExpansionTy;
+  }
+  case 'e': {
+    NodePointer PackTy = popTypeAndGetChild();
+    int level = demangleIndex();
+    if (level < 0)
+      return NULL;
+
+    NodePointer PackElementTy = createType(
+          createWithChildren(Node::Kind::PackElement, PackTy,
+              createNode(Node::Kind::PackElementLevel, level)));
+    return PackElementTy;
+  }
+  case 'P':
+    return popPack();
+  case 'S':
+    return popSILPack();
   default:
     return nullptr;
   }
@@ -2260,6 +2693,8 @@ NodePointer Demangler::popAssocTypeName() {
   // If we haven't seen a protocol, check for a symbolic reference.
   if (!Proto)
     Proto = popNode(Node::Kind::ProtocolSymbolicReference);
+  if (!Proto)
+    Proto = popNode(Node::Kind::ObjectiveCProtocolSymbolicReference);
 
   NodePointer Id = popNode(Node::Kind::Identifier);
   NodePointer AssocTy = createWithChild(Node::Kind::DependentAssociatedTypeRef, Id);
@@ -2300,6 +2735,9 @@ NodePointer Demangler::demangleGenericParamIndex() {
   if (nextIf('z')) {
     return getDependentGenericParamType(0, 0);
   }
+  if (nextIf('s')) {
+    return createNode(Node::Kind::ConstrainedExistentialSelf);
+  }
   return getDependentGenericParamType(0, demangleIndex() + 1);
 }
 
@@ -2333,6 +2771,8 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
     case 'O': return createNode(Node::Kind::NonObjCAttribute);
     case 'D': return createNode(Node::Kind::DynamicAttribute);
     case 'd': return createNode(Node::Kind::DirectMethodReferenceAttribute);
+    case 'E': return createNode(Node::Kind::DistributedThunk);
+    case 'F': return createNode(Node::Kind::DistributedAccessor);
     case 'a': return createNode(Node::Kind::PartialApplyObjCForwarder);
     case 'A': return createNode(Node::Kind::PartialApplyForwarder);
     case 'm': return createNode(Node::Kind::MergedFunction);
@@ -2546,6 +2986,8 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
       int Idx = demangleIndex();
       if (Idx < 0)
         return nullptr;
+      if (nextChar() == 'r')
+        return createNode(Node::Kind::OutlinedReadOnlyObject, Idx);
       return createNode(Node::Kind::OutlinedVariable, Idx);
     }
     case 'e': {
@@ -2585,6 +3027,14 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
         return demangleAutoDiffFunctionOrSimpleThunk(
             Node::Kind::AutoDiffFunction);
       }
+    case 'w':
+      switch (nextChar()) {
+      case 'b': return createNode(Node::Kind::BackDeploymentThunk);
+      case 'B': return createNode(Node::Kind::BackDeploymentFallback);
+      case 'S': return createNode(Node::Kind::HasSymbolQuery);
+      default:
+        return nullptr;
+      }
     default:
       return nullptr;
   }
@@ -2639,7 +3089,8 @@ NodePointer Demangler::demangleAutoDiffSelfReorderingReabstractionThunk() {
   addChild(result, popNode(Node::Kind::DependentGenericSignature));
   result = addChild(result, popNode(Node::Kind::Type));
   result = addChild(result, popNode(Node::Kind::Type));
-  result->reverseChildren();
+  if (result)
+    result->reverseChildren();
   result = addChild(result, demangleAutoDiffFunctionKind());
   return result;
 }
@@ -2694,6 +3145,28 @@ NodePointer Demangler::demangleDifferentiableFunctionType() {
       Node::Kind::DifferentiableFunctionType, (Node::IndexType)kind);
 }
 
+NodePointer Demangler::demangleLifetimeDependenceKind(bool isSelfDependence) {
+  MangledLifetimeDependenceKind kind;
+  switch (auto c = nextChar()) {
+  case 's':
+    kind = MangledLifetimeDependenceKind::Scope;
+    break;
+  case 'i':
+    kind = MangledLifetimeDependenceKind::Inherit;
+    break;
+  default:
+    return nullptr;
+  }
+  if (isSelfDependence) {
+    return createNode(Node::Kind::SelfLifetimeDependence,
+                      (Node::IndexType)kind);
+  }
+  auto node = createWithChildren(Node::Kind::ParamLifetimeDependence,
+                                 createNode(Node::Kind::Index, unsigned(kind)),
+                                 popTypeAndGetChild());
+  return createType(node);
+}
+
 std::string Demangler::demangleBridgedMethodParams() {
   if (nextIf('_'))
     return std::string();
@@ -2704,7 +3177,7 @@ std::string Demangler::demangleBridgedMethodParams() {
   switch (kind) {
   default:
     return std::string();
-  case 'p': case 'a': case 'm':
+  case 'o': case 'p': case 'a': case 'm':
     Str.push_back(kind);
   }
 
@@ -2759,10 +3232,12 @@ NodePointer Demangler::demangleFunctionSpecialization() {
       case FunctionSigSpecializationParamKind::ConstantPropFunction:
       case FunctionSigSpecializationParamKind::ConstantPropGlobal:
       case FunctionSigSpecializationParamKind::ConstantPropString:
+      case FunctionSigSpecializationParamKind::ConstantPropKeyPath:
       case FunctionSigSpecializationParamKind::ClosureProp: {
         size_t FixedChildren = Param->getNumChildren();
         while (NodePointer Ty = popNode(Node::Kind::Type)) {
-          if (ParamKind != FunctionSigSpecializationParamKind::ClosureProp)
+          if (ParamKind != FunctionSigSpecializationParamKind::ClosureProp &&
+              ParamKind != FunctionSigSpecializationParamKind::ConstantPropKeyPath)
             return nullptr;
           Param = addChild(Param, Ty);
         }
@@ -2844,6 +3319,14 @@ NodePointer Demangler::demangleFuncSpecParam(Node::Kind Kind) {
                   Node::Kind::FunctionSignatureSpecializationParamPayload,
                   Encoding));
         }
+        case 'k': {
+          // Consumes two types and a SHA1 identifier.
+          return addChild(
+              Param,
+              createNode(Node::Kind::FunctionSignatureSpecializationParamKind,
+                         Node::IndexType(FunctionSigSpecializationParamKind::
+                                             ConstantPropKeyPath)));
+        }
         default:
           return nullptr;
       }
@@ -2908,6 +3391,11 @@ NodePointer Demangler::demangleFuncSpecParam(Node::Kind Kind) {
       return addChild(Param, createNode(
                 Node::Kind::FunctionSignatureSpecializationParamKind,
                 unsigned(FunctionSigSpecializationParamKind::BoxToStack)));
+    case 'r':
+      return addChild(
+          Param,
+          createNode(Node::Kind::FunctionSignatureSpecializationParamKind,
+                     unsigned(FunctionSigSpecializationParamKind::InOutToOut)));
     default:
       return nullptr;
   }
@@ -2929,17 +3417,28 @@ NodePointer Demangler::addFuncSpecParamNumber(NodePointer Param,
 }
 
 NodePointer Demangler::demangleSpecAttributes(Node::Kind SpecKind) {
+  bool metatypeParamsRemoved = nextIf('m');
   bool isSerialized = nextIf('q');
+  bool asyncRemoved = nextIf('a');
 
   int PassID = (int)nextChar() - '0';
-  if (PassID < 0 || PassID > 9)
+  if (PassID < 0 || PassID >= MAX_SPECIALIZATION_PASS) {
     return nullptr;
+  }
 
   NodePointer SpecNd = createNode(SpecKind);
+
+  if (metatypeParamsRemoved)
+    SpecNd->addChild(createNode(Node::Kind::MetatypeParamsRemoved), *this);
+
   if (isSerialized)
     SpecNd->addChild(createNode(Node::Kind::IsSerialized),
                      *this);
 
+  if (asyncRemoved)
+    SpecNd->addChild(createNode(Node::Kind::AsyncRemoved),
+                     *this);
+
   SpecNd->addChild(createNode(Node::Kind::SpecializationPassID, PassID),
                    *this);
   return SpecNd;
@@ -3021,6 +3520,34 @@ NodePointer Demangler::demangleWitness() {
     }
     case 'O': {
       switch (nextChar()) {
+      case 'C': {
+        if (auto sig = popNode(Node::Kind::DependentGenericSignature))
+          return createWithChildren(Node::Kind::OutlinedInitializeWithCopyNoValueWitness,
+                                    popNode(Node::Kind::Type), sig);
+        return createWithChild(Node::Kind::OutlinedInitializeWithCopyNoValueWitness,
+                               popNode(Node::Kind::Type));
+      }
+      case 'D': {
+        if (auto sig = popNode(Node::Kind::DependentGenericSignature))
+          return createWithChildren(Node::Kind::OutlinedAssignWithTakeNoValueWitness,
+                                    popNode(Node::Kind::Type), sig);
+        return createWithChild(Node::Kind::OutlinedAssignWithTakeNoValueWitness,
+                               popNode(Node::Kind::Type));
+      }
+      case 'F': {
+        if (auto sig = popNode(Node::Kind::DependentGenericSignature))
+          return createWithChildren(Node::Kind::OutlinedAssignWithCopyNoValueWitness,
+                                    popNode(Node::Kind::Type), sig);
+        return createWithChild(Node::Kind::OutlinedAssignWithCopyNoValueWitness,
+                               popNode(Node::Kind::Type));
+      }
+      case 'H': {
+        if (auto sig = popNode(Node::Kind::DependentGenericSignature))
+          return createWithChildren(Node::Kind::OutlinedDestroyNoValueWitness,
+                                    popNode(Node::Kind::Type), sig);
+        return createWithChild(Node::Kind::OutlinedDestroyNoValueWitness,
+                               popNode(Node::Kind::Type));
+      }
       case 'y': {
         if (auto sig = popNode(Node::Kind::DependentGenericSignature))
           return createWithChildren(Node::Kind::OutlinedCopy,
@@ -3084,6 +3611,33 @@ NodePointer Demangler::demangleWitness() {
         return createWithChild(Node::Kind::OutlinedDestroy,
                                popNode(Node::Kind::Type));
       }
+      case 'g': {
+        if (auto sig = popNode(Node::Kind::DependentGenericSignature))
+          return createWithChildren(Node::Kind::OutlinedEnumGetTag,
+                                    popNode(Node::Kind::Type), sig);
+        return createWithChild(Node::Kind::OutlinedEnumGetTag,
+                               popNode(Node::Kind::Type));
+      }
+
+      case 'i': {
+        auto enumCaseIdx = demangleIndexAsNode();
+        if (auto sig = popNode(Node::Kind::DependentGenericSignature))
+          return createWithChildren(Node::Kind::OutlinedEnumTagStore,
+                                    popNode(Node::Kind::Type), sig,
+                                    enumCaseIdx);
+        return createWithChildren(Node::Kind::OutlinedEnumTagStore,
+                                  popNode(Node::Kind::Type), enumCaseIdx);
+      }
+      case 'j': {
+        auto enumCaseIdx = demangleIndexAsNode();
+        if (auto sig = popNode(Node::Kind::DependentGenericSignature))
+          return createWithChildren(Node::Kind::OutlinedEnumProjectDataForLoad,
+                                    popNode(Node::Kind::Type), sig,
+                                    enumCaseIdx);
+        return createWithChildren(Node::Kind::OutlinedEnumProjectDataForLoad,
+                                  popNode(Node::Kind::Type), enumCaseIdx);
+      }
+
       default:
         return nullptr;
       }
@@ -3137,6 +3691,11 @@ NodePointer Demangler::demangleSpecialType() {
       return popFunctionType(Node::Kind::ObjCBlock);
     case 'C':
       return popFunctionType(Node::Kind::CFunctionPointer);
+    case 'g':
+    case 'G':
+      return demangleExtendedExistentialShape(specialChar);
+    case 'j':
+      return demangleSymbolicExtendedExistentialType();
     case 'z':
       switch (auto cchar = nextChar()) {
       case 'B':
@@ -3172,6 +3731,12 @@ NodePointer Demangler::demangleSpecialType() {
       return createType(createWithChildren(Node::Kind::ExistentialMetatype,
                                            MTR, Type));
     }
+    case 'P': {
+      NodePointer Reqs = demangleConstrainedExistentialRequirementList();
+      NodePointer Base = popNode(Node::Kind::Type);
+      return createType(
+          createWithChildren(Node::Kind::ConstrainedExistential, Base, Reqs));
+    }
     case 'p':
       return createType(createWithChild(Node::Kind::ExistentialMetatype,
                                         popNode(Node::Kind::Type)));
@@ -3204,7 +3769,7 @@ NodePointer Demangler::demangleSpecialType() {
         return nullptr;
       // Build layout.
       auto layout = createNode(Node::Kind::SILBoxLayout);
-      for (unsigned i = 0, e = fieldTypes->getNumChildren(); i < e; ++i) {
+      for (size_t i = 0, e = fieldTypes->getNumChildren(); i < e; ++i) {
         auto fieldType = fieldTypes->getChild(i);
         assert(fieldType->getKind() == Node::Kind::Type);
         bool isMutable = false;
@@ -3268,6 +3833,54 @@ NodePointer Demangler::demangleSpecialType() {
   }
 }
 
+NodePointer Demangler::demangleSymbolicExtendedExistentialType() {
+  NodePointer retroactiveConformances = popRetroactiveConformances();
+
+  NodePointer args = createNode(Node::Kind::TypeList);
+  while (NodePointer ty = popNode(Node::Kind::Type)) {
+    args->addChild(ty, *this);
+  }
+  args->reverseChildren();
+
+  auto shape = popNode();
+  if (!shape)
+    return nullptr;
+  if (shape->getKind() !=
+        Node::Kind::UniqueExtendedExistentialTypeShapeSymbolicReference &&
+      shape->getKind() !=
+        Node::Kind::NonUniqueExtendedExistentialTypeShapeSymbolicReference)
+    return nullptr;
+
+  NodePointer existentialType;
+  if (!retroactiveConformances) {
+    existentialType =
+      createWithChildren(Node::Kind::SymbolicExtendedExistentialType,
+                         shape, args);
+  } else {
+    existentialType =
+      createWithChildren(Node::Kind::SymbolicExtendedExistentialType,
+                         shape, args, retroactiveConformances);
+  }
+  return createType(existentialType);
+}
+
+NodePointer Demangler::demangleExtendedExistentialShape(char nodeKind) {
+  assert(nodeKind == 'g' || nodeKind == 'G');
+
+  NodePointer type = popNode(Node::Kind::Type);
+
+  NodePointer genSig = nullptr;
+  if (nodeKind == 'G')
+    genSig = popNode(Node::Kind::DependentGenericSignature);
+
+  if (genSig) {
+    return createWithChildren(Node::Kind::ExtendedExistentialTypeShape,
+                              genSig, type);
+  } else {
+    return createWithChild(Node::Kind::ExtendedExistentialTypeShape, type);
+  }
+}
+
 NodePointer Demangler::demangleMetatypeRepresentation() {
   switch (nextChar()) {
     case 't':
@@ -3293,6 +3906,7 @@ NodePointer Demangler::demangleAccessor(NodePointer ChildNode) {
     case 'W': Kind = Node::Kind::DidSet; break;
     case 'r': Kind = Node::Kind::ReadAccessor; break;
     case 'M': Kind = Node::Kind::ModifyAccessor; break;
+    case 'i': Kind = Node::Kind::InitAccessor; break;
     case 'a':
       switch (nextChar()) {
         case 'O': Kind = Node::Kind::OwningMutableAddressor; break;
@@ -3324,7 +3938,8 @@ NodePointer Demangler::demangleFunctionEntity() {
     None,
     TypeAndMaybePrivateName,
     TypeAndIndex,
-    Index
+    Index,
+    ContextArg,
   } Args;
 
   Node::Kind Kind = Node::Kind::EmptyList;
@@ -3341,6 +3956,8 @@ NodePointer Demangler::demangleFunctionEntity() {
     case 'U': Args = TypeAndIndex; Kind = Node::Kind::ExplicitClosure; break;
     case 'u': Args = TypeAndIndex; Kind = Node::Kind::ImplicitClosure; break;
     case 'A': Args = Index; Kind = Node::Kind::DefaultArgumentInitializer; break;
+    case 'm': return demangleEntity(Node::Kind::Macro);
+    case 'M': return demangleMacroExpansion();
     case 'p': return demangleEntity(Node::Kind::GenericTypeParamDecl);
     case 'P':
       Args = None;
@@ -3353,7 +3970,8 @@ NodePointer Demangler::demangleFunctionEntity() {
     default: return nullptr;
   }
 
-  NodePointer NameOrIndex = nullptr, ParamType = nullptr, LabelList = nullptr;
+  NodePointer NameOrIndex = nullptr, ParamType = nullptr, LabelList = nullptr,
+              Context = nullptr;
   switch (Args) {
     case None:
       break;
@@ -3369,6 +3987,9 @@ NodePointer Demangler::demangleFunctionEntity() {
     case Index:
       NameOrIndex = demangleIndexAsNode();
       break;
+    case ContextArg:
+      Context = popNode();
+      break;
   }
   NodePointer Entity = createWithChild(Kind, popContext());
   switch (Args) {
@@ -3386,6 +4007,9 @@ NodePointer Demangler::demangleFunctionEntity() {
       Entity = addChild(Entity, NameOrIndex);
       Entity = addChild(Entity, ParamType);
       break;
+    case ContextArg:
+      Entity = addChild(Entity, Context);
+      break;
   }
   return Entity;
 }
@@ -3395,8 +4019,11 @@ NodePointer Demangler::demangleEntity(Node::Kind Kind) {
   NodePointer LabelList = popFunctionParamLabels(Type);
   NodePointer Name = popNode(isDeclName);
   NodePointer Context = popContext();
-  return LabelList ? createWithChildren(Kind, Context, Name, LabelList, Type)
-                   : createWithChildren(Kind, Context, Name, Type);
+  auto result = LabelList ? createWithChildren(Kind, Context, Name, LabelList, Type)
+                          : createWithChildren(Kind, Context, Name, Type);
+                          
+  result = setParentForOpaqueReturnTypeNodes(*this, result, Type);
+  return result;
 }
 
 NodePointer Demangler::demangleVariable() {
@@ -3410,11 +4037,16 @@ NodePointer Demangler::demangleSubscript() {
   NodePointer LabelList = popFunctionParamLabels(Type);
   NodePointer Context = popContext();
 
+  if (!Type)
+    return nullptr;
+
   NodePointer Subscript = createNode(Node::Kind::Subscript);
   Subscript = addChild(Subscript, Context);
   addChild(Subscript, LabelList);
   Subscript = addChild(Subscript, Type);
   addChild(Subscript, PrivateName);
+  
+  Subscript = setParentForOpaqueReturnTypeNodes(*this, Subscript, Type);
 
   return demangleAccessor(Subscript);
 }
@@ -3442,6 +4074,22 @@ NodePointer Demangler::demangleProtocolListType() {
   return createType(ProtoList);
 }
 
+NodePointer Demangler::demangleConstrainedExistentialRequirementList() {
+  NodePointer ReqList =
+      createNode(Node::Kind::ConstrainedExistentialRequirementList);
+  bool firstElem = false;
+  do {
+    firstElem = (popNode(Node::Kind::FirstElementMarker) != nullptr);
+    NodePointer Req = popNode(isRequirement);
+    if (!Req)
+      return nullptr;
+    ReqList->addChild(Req, *this);
+  } while (!firstElem);
+
+  ReqList->reverseChildren();
+  return ReqList;
+}
+
 NodePointer Demangler::demangleGenericSignature(bool hasParamCounts) {
   NodePointer Sig = createNode(Node::Kind::DependentGenericSignature);
   if (hasParamCounts) {
@@ -3467,11 +4115,13 @@ NodePointer Demangler::demangleGenericSignature(bool hasParamCounts) {
 }
 
 NodePointer Demangler::demangleGenericRequirement() {
-  
+
   enum { Generic, Assoc, CompoundAssoc, Substitution } TypeKind;
-  enum { Protocol, BaseClass, SameType, Layout } ConstraintKind;
-  
+  enum { Protocol, BaseClass, SameType, SameShape, Layout, PackMarker, Inverse } ConstraintKind;
+
+  NodePointer inverseKind = nullptr;
   switch (nextChar()) {
+    case 'v': ConstraintKind = PackMarker; TypeKind = Generic; break;
     case 'c': ConstraintKind = BaseClass; TypeKind = Assoc; break;
     case 'C': ConstraintKind = BaseClass; TypeKind = CompoundAssoc; break;
     case 'b': ConstraintKind = BaseClass; TypeKind = Generic; break;
@@ -3487,6 +4137,21 @@ NodePointer Demangler::demangleGenericRequirement() {
     case 'p': ConstraintKind = Protocol; TypeKind = Assoc; break;
     case 'P': ConstraintKind = Protocol; TypeKind = CompoundAssoc; break;
     case 'Q': ConstraintKind = Protocol; TypeKind = Substitution; break;
+    case 'h': ConstraintKind = SameShape; TypeKind = Generic; break;
+    case 'i': 
+      ConstraintKind = Inverse;
+      TypeKind = Generic;
+      inverseKind = demangleIndexAsNode();
+      if (!inverseKind)
+        return nullptr;
+      break;
+    case 'I': 
+      ConstraintKind = Inverse;
+      TypeKind = Substitution;
+      inverseKind = demangleIndexAsNode();
+      if (!inverseKind)
+        return nullptr;
+      break;
     default:  ConstraintKind = Protocol; TypeKind = Generic; pushBack(); break;
   }
 
@@ -3510,10 +4175,17 @@ NodePointer Demangler::demangleGenericRequirement() {
   }
 
   switch (ConstraintKind) {
+  case PackMarker:
+    return createWithChild(
+        Node::Kind::DependentGenericParamPackMarker, ConstrTy);
   case Protocol:
     return createWithChildren(
         Node::Kind::DependentGenericConformanceRequirement, ConstrTy,
         popProtocol());
+  case Inverse:
+    return createWithChildren(
+        Node::Kind::DependentGenericInverseConformanceRequirement,
+        ConstrTy, inverseKind);
   case BaseClass:
     return createWithChildren(
         Node::Kind::DependentGenericConformanceRequirement, ConstrTy,
@@ -3521,6 +4193,9 @@ NodePointer Demangler::demangleGenericRequirement() {
   case SameType:
     return createWithChildren(Node::Kind::DependentGenericSameTypeRequirement,
                               ConstrTy, popNode(Node::Kind::Type));
+  case SameShape:
+    return createWithChildren(Node::Kind::DependentGenericSameShapeRequirement,
+                              ConstrTy, popNode(Node::Kind::Type));
   case Layout: {
     auto c = nextChar();
     NodePointer size = nullptr;
@@ -3538,6 +4213,8 @@ NodePointer Demangler::demangleGenericRequirement() {
       name = "D";
     } else if (c == 'T') {
       name = "T";
+    } else if (c == 'B') {
+      name = "B";
     } else if (c == 'E') {
       size = demangleIndexAsNode();
       if (!size)
@@ -3560,14 +4237,19 @@ NodePointer Demangler::demangleGenericRequirement() {
       if (!size)
         return nullptr;
       name = "m";
+    } else if (c == 'S') {
+      size = demangleIndexAsNode();
+      if (!size)
+        return nullptr;
+      name = "S";
     } else {
       // Unknown layout constraint.
       return nullptr;
     }
 
     auto NameNode = createNode(Node::Kind::Identifier, name);
-    auto LayoutRequirement = createWithChildren(
-        Node::Kind::DependentGenericLayoutRequirement, ConstrTy, NameNode);
+    auto NodeKind = Node::Kind::DependentGenericLayoutRequirement;
+    auto LayoutRequirement = createWithChildren(NodeKind, ConstrTy, NameNode);
     if (size)
       addChild(LayoutRequirement, size);
     if (alignment)
@@ -3603,3 +4285,82 @@ NodePointer Demangler::demangleValueWitness() {
   addChild(VW, createNode(Node::Kind::Index, unsigned(Kind)));
   return addChild(VW, popNode(Node::Kind::Type));
 }
+
+static bool isMacroExpansionNodeKind(Node::Kind kind) {
+  return kind == Node::Kind::AccessorAttachedMacroExpansion ||
+         kind == Node::Kind::MemberAttributeAttachedMacroExpansion ||
+         kind == Node::Kind::FreestandingMacroExpansion ||
+         kind == Node::Kind::MemberAttachedMacroExpansion ||
+         kind == Node::Kind::PeerAttachedMacroExpansion ||
+         kind == Node::Kind::ConformanceAttachedMacroExpansion ||
+         kind == Node::Kind::ExtensionAttachedMacroExpansion ||
+         kind == Node::Kind::MacroExpansionLoc;
+}
+
+NodePointer Demangler::demangleMacroExpansion() {
+  Node::Kind kind;
+  bool isAttached;
+  bool isFreestanding;
+  switch (nextChar()) {
+#define FREESTANDING_MACRO_ROLE(Name, Description)
+#define ATTACHED_MACRO_ROLE(Name, Description, MangledChar)    \
+  case MangledChar[0]:                                         \
+    kind = Node::Kind::Name##AttachedMacroExpansion;           \
+    isAttached = true;                                         \
+    isFreestanding = false;                                    \
+    break;
+#include "swift/Basic/MacroRoles.def"
+
+  case 'f':
+    kind = Node::Kind::FreestandingMacroExpansion;
+    isAttached = false;
+    isFreestanding = true;
+    break;
+
+  case 'u':
+    kind = Node::Kind::MacroExpansionUniqueName;
+    isAttached = false;
+    isFreestanding = false;
+    break;
+
+  case 'X': {
+    kind = Node::Kind::MacroExpansionLoc;
+
+    int line = demangleIndex();
+    int col = demangleIndex();
+
+    auto lineNode = createNode(Node::Kind::Index, line);
+    auto colNode = createNode(Node::Kind::Index, col);
+
+    NodePointer buffer = popNode(Node::Kind::Identifier);
+    NodePointer module = popNode(Node::Kind::Identifier);
+    return createWithChildren(kind, module, buffer, lineNode, colNode);
+  }
+
+  default:
+    return nullptr;
+  }
+
+  NodePointer macroName = popNode(Node::Kind::Identifier);
+  NodePointer privateDiscriminator = nullptr;
+  if (isFreestanding)
+    privateDiscriminator = popNode(Node::Kind::PrivateDeclName);
+  NodePointer attachedName = nullptr;
+  if (isAttached)
+    attachedName = popNode(isDeclName);
+
+  NodePointer context = popNode(isMacroExpansionNodeKind);
+  if (!context)
+    context = popContext();
+  NodePointer discriminator = demangleIndexAsNode();
+  NodePointer result;
+  if (isAttached) {
+    result = createWithChildren(
+        kind, context, attachedName, macroName, discriminator);
+  } else {
+    result = createWithChildren(kind, context, macroName, discriminator);
+  }
+  if (privateDiscriminator)
+    result->addChild(privateDiscriminator, *this);
+  return result;
+}
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/DemanglerAssert.h b/symbolic-demangle/vendor/swift/lib/Demangling/DemanglerAssert.h
new file mode 100644
index 000000000..367a81ef7
--- /dev/null
+++ b/symbolic-demangle/vendor/swift/lib/Demangling/DemanglerAssert.h
@@ -0,0 +1,68 @@
+//===--- DemanglerAssert.h - Assertions for de/re-mangling ------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a macro, DEMANGLE_ASSERT(), which will assert in the
+// compiler, but in the runtime will return a ManglingError on failure.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_DEMANGLING_ASSERT_H
+#define SWIFT_DEMANGLING_ASSERT_H
+
+#include "llvm/Support/Compiler.h"
+#include "swift/Demangling/Demangle.h"
+#include "swift/Demangling/NamespaceMacros.h"
+
+#if defined(NDEBUG) || defined (SWIFT_RUNTIME)
+
+// In the runtime and non-asserts builds, DEMANGLER_ASSERT() returns an error.
+#define DEMANGLER_ASSERT(expr, node)                                           \
+  do {                                                                         \
+    if (!(expr))                                                               \
+      return ManglingError(ManglingError::AssertionFailed, (node), __LINE__);  \
+  } while (0)
+
+#else
+
+// Except in unittests, assert builds cause DEMANGLER_ASSERT() to assert()
+#define DEMANGLER_ASSERT(expr, node)                                           \
+  do {                                                                         \
+    if (!(expr)) {                                                             \
+      if (Factory.disableAssertionsForUnitTest)                                \
+        return ManglingError(ManglingError::AssertionFailed, (node),           \
+                             __LINE__);                                        \
+      else                                                                     \
+        swift::Demangle::failAssert(__FILE__, __LINE__, node, #expr);          \
+    }                                                                          \
+  } while (0)
+
+#endif
+
+// DEMANGLER_ALWAYS_ASSERT() *always* fails the program, even in the runtime
+#define DEMANGLER_ALWAYS_ASSERT(expr, node)                                    \
+  do {                                                                         \
+    if (!(expr))                                                               \
+      swift::Demangle::failAssert(__FILE__, __LINE__, node, #expr);            \
+  } while (0)
+
+namespace swift {
+namespace Demangle {
+SWIFT_BEGIN_INLINE_NAMESPACE
+
+[[noreturn]] void failAssert(const char *file, unsigned line, NodePointer node,
+                             const char *expr);
+
+SWIFT_END_INLINE_NAMESPACE
+} // end namespace Demangle
+} // end namespace swift
+
+#endif // SWIFT_DEMANGLING_ASSERT_H
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/Errors.cpp b/symbolic-demangle/vendor/swift/lib/Demangling/Errors.cpp
new file mode 100644
index 000000000..299891ac7
--- /dev/null
+++ b/symbolic-demangle/vendor/swift/lib/Demangling/Errors.cpp
@@ -0,0 +1,227 @@
+//===--- Errors.cpp - Demangling library error handling ---------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Provides the demangling library with its own error handling functions.
+// This is necessary because it isn't always linked with the runtime, so
+// it can't use the runtime's error handling.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Demangling/Errors.h"
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_WIN32)
+#include <io.h>
+#endif
+
+#if SWIFT_STDLIB_HAS_ASL
+#include <asl.h>
+#elif defined(__ANDROID__)
+#include <android/log.h>
+#endif
+
+#if SWIFT_HAVE_CRASHREPORTERCLIENT
+#include <atomic>
+#include <malloc/malloc.h>
+
+#include "swift/Runtime/Atomic.h"
+
+#include "CrashReporter.h"
+#endif // SWIFT_HAVE_CRASHREPORTERCLIENT
+
+// -- Declarations -----------------------------------------------------------
+
+static SWIFT_NORETURN void demangleFatal(uint32_t flags, const char *format,
+                                         va_list val);
+static void demangleWarn(uint32_t flags, const char *format, va_list val);
+
+static int demangle_vasprintf(char **strp, const char *format, va_list val);
+
+#if SWIFT_HAVE_CRASHREPORTERCLIENT
+static int demangle_asprintf(char **strp, const char *format, ...);
+#endif
+
+// -- Crash reporter integration ---------------------------------------------
+
+// Report a message to any forthcoming crash log.
+static void reportOnCrash(uint32_t flags, const char *message) {
+#if SWIFT_HAVE_CRASHREPORTERCLIENT
+  char *oldMessage = nullptr;
+  char *newMessage = nullptr;
+
+  oldMessage = std::atomic_load_explicit(
+    (volatile std::atomic<char *> *)&gCRAnnotations.message,
+    SWIFT_MEMORY_ORDER_CONSUME);
+
+  do {
+    if (newMessage) {
+      free(newMessage);
+      newMessage = nullptr;
+    }
+
+    if (oldMessage) {
+      demangle_asprintf(&newMessage, "%s%s", oldMessage, message);
+    } else {
+      newMessage = strdup(message);
+    }
+  } while (!std::atomic_compare_exchange_strong_explicit(
+             (volatile std::atomic<char *> *)&gCRAnnotations.message,
+             &oldMessage, newMessage,
+             std::memory_order_release,
+             SWIFT_MEMORY_ORDER_CONSUME));
+
+  if (oldMessage && malloc_size(oldMessage))
+    free(oldMessage);
+#else
+  // empty
+#endif // SWIFT_HAVE_CRASHREPORTERCLIENT
+}
+
+// -- Utility functions ------------------------------------------------------
+
+// Report a message to system console and stderr.
+static void reportNow(uint32_t flags, const char *message) {
+#if defined(_WIN32)
+#define STDERR_FILENO 2
+  _write(STDERR_FILENO, message, strlen(message));
+#else
+  fputs(message, stderr);
+  fflush(stderr);
+#endif
+#if SWIFT_STDLIB_HAS_ASL
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", message);
+#pragma clang diagnostic pop
+#elif defined(__ANDROID__) && !defined(__TERMUX__)
+  __android_log_print(ANDROID_LOG_FATAL, "SwiftDemangle", "%s", message);
+#endif
+}
+
+/// Report a fatal error to system console, stderr, and crash logs.
+/// Does not crash by itself.
+static void reportError(uint32_t flags, const char *message) {
+  reportNow(flags, message);
+  reportOnCrash(flags, message);
+}
+
+/// Not everything has vasprintf()
+SWIFT_VFORMAT(2)
+static int demangle_vasprintf(char **strp, const char *format, va_list args) {
+  va_list args_for_len;
+
+  va_copy(args_for_len, args);
+  int len = vsnprintf(nullptr, 0, format, args_for_len);
+  va_end(args_for_len);
+
+  *strp = nullptr;
+
+  if (len < 0)
+    return -1;
+
+  size_t bufsiz = len + 1;
+  char *buffer = reinterpret_cast<char *>(malloc(bufsiz));
+  if (!buffer)
+    return -1;
+
+  int result = vsnprintf(buffer, bufsiz, format, args);
+  if (result < 0) {
+    free(buffer);
+    return -1;
+  }
+
+  *strp = buffer;
+  return result;
+}
+
+#if SWIFT_HAVE_CRASHREPORTERCLIENT
+SWIFT_FORMAT(2,3)
+static int demangle_asprintf(char **strp, const char *format, ...) {
+  va_list val;
+
+  va_start(val, format);
+  int ret = demangle_vasprintf(strp, format, val);
+  va_end(val);
+
+  return ret;
+}
+#endif // SWIFT_HAVE_CRASHREPORTERCLIENT
+
+// -- Implementation ---------------------------------------------------------
+
+SWIFT_VFORMAT(2)
+static SWIFT_NORETURN void demangleFatal(uint32_t flags, const char *format,
+                                         va_list val) {
+  char *message;
+
+  if (demangle_vasprintf(&message, format, val) < 0) {
+    reportError(flags, "unable to format fatal error message");
+    abort();
+  }
+
+  reportError(flags, message);
+  abort();
+}
+
+SWIFT_VFORMAT(2)
+static void demangleWarn(uint32_t flags, const char *format, va_list val) {
+  char *message;
+
+  if (demangle_vasprintf(&message, format, val) < 0) {
+    reportNow(flags, "unable to format warning message");
+    return;
+  }
+
+  reportNow(flags, message);
+  free(message);
+}
+
+// -- Public API -------------------------------------------------------------
+
+namespace swift {
+namespace Demangle {
+SWIFT_BEGIN_INLINE_NAMESPACE
+
+SWIFT_FORMAT(2, 3)
+SWIFT_NORETURN void fatal(uint32_t flags, const char *format, ...) {
+  va_list val;
+
+  va_start(val, format);
+  fatalv(flags, format, val);
+}
+
+SWIFT_FORMAT(2, 3)
+void warn(uint32_t flags, const char *format, ...) {
+  va_list val;
+
+  va_start(val, format);
+  warnv(flags, format, val);
+  va_end(val);
+}
+
+SWIFT_VFORMAT(2)
+SWIFT_NORETURN void fatalv(uint32_t flags, const char *format, va_list val) {
+  demangleFatal(flags, format, val);
+}
+
+SWIFT_VFORMAT(2)
+void warnv(uint32_t flags, const char *format, va_list val) {
+  demangleWarn(flags, format, val);
+}
+
+SWIFT_END_INLINE_NAMESPACE
+} // end namespace Demangle
+} // end namespace swift
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/ManglingUtils.cpp b/symbolic-demangle/vendor/swift/lib/Demangling/ManglingUtils.cpp
index 4a42108a4..0a1655e39 100644
--- a/symbolic-demangle/vendor/swift/lib/Demangling/ManglingUtils.cpp
+++ b/symbolic-demangle/vendor/swift/lib/Demangling/ManglingUtils.cpp
@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/Demangling/ManglingUtils.h"
+#include <optional>
 
 using namespace swift;
 using namespace Mangle;
@@ -66,19 +67,20 @@ std::string Mangle::translateOperator(StringRef Op) {
   return Encoded;
 }
 
-llvm::Optional<StringRef> Mangle::getStandardTypeSubst(StringRef TypeName) {
+std::optional<StringRef>
+Mangle::getStandardTypeSubst(StringRef TypeName,
+                             bool allowConcurrencyManglings) {
 #define STANDARD_TYPE(KIND, MANGLING, TYPENAME)      \
   if (TypeName == #TYPENAME) {                       \
     return StringRef(#MANGLING);                     \
   }
 
-#define STANDARD_TYPE_2(KIND, MANGLING, TYPENAME)    \
-  if (TypeName == #TYPENAME) {                       \
-    return StringRef("c" #MANGLING);                 \
+#define STANDARD_TYPE_CONCURRENCY(KIND, MANGLING, TYPENAME)    \
+  if (allowConcurrencyManglings && TypeName == #TYPENAME) {    \
+    return StringRef("c" #MANGLING);                           \
   }
 
 #include "swift/Demangling/StandardTypesMangling.def"
 
-  return llvm::None;
+  return std::nullopt;
 }
-
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/NodePrinter.cpp b/symbolic-demangle/vendor/swift/lib/Demangling/NodePrinter.cpp
index 34fa785b9..5b251e8da 100644
--- a/symbolic-demangle/vendor/swift/lib/Demangling/NodePrinter.cpp
+++ b/symbolic-demangle/vendor/swift/lib/Demangling/NodePrinter.cpp
@@ -14,24 +14,19 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/AST/Ownership.h"
 #include "swift/Basic/STLExtras.h"
 #include "swift/Demangling/Demangle.h"
-#include "swift/AST/Ownership.h"
 #include "swift/Strings.h"
 #include <cassert>
 #include <cstdio>
 #include <cstdlib>
+#include <vector>
 
 using namespace swift;
 using namespace Demangle;
 using llvm::StringRef;
 
-[[noreturn]]
-static void printer_unreachable(const char *Message) {
-  fprintf(stderr, "fatal error: %s\n", Message);
-  std::abort();
-}
-
 DemanglerPrinter &DemanglerPrinter::operator<<(unsigned long long n) & {
   char buffer[32];
   snprintf(buffer, sizeof(buffer), "%llu", n);
@@ -51,6 +46,14 @@ DemanglerPrinter &DemanglerPrinter::operator<<(long long n) & {
   return *this;
 }
 
+#if SWIFT_STDLIB_HAS_TYPE_PRINTING
+
+[[noreturn]]
+static void printer_unreachable(const char *Message) {
+  fprintf(stderr, "fatal error: %s\n", Message);
+  std::abort();
+}
+
 std::string Demangle::genericParameterName(uint64_t depth, uint64_t index) {
   DemanglerPrinter name;
   do {
@@ -173,16 +176,18 @@ class NodePrinter {
 
 public:
   NodePrinter(DemangleOptions options) : Options(options) {}
-  
+
   std::string printRoot(NodePointer root) {
     isValid = true;
-    print(root);
+    print(root, 0);
     if (isValid)
       return std::move(Printer).str();
     return "";
   }
 
 private:
+  static const unsigned MaxDepth = 768;
+
   /// Called when the node tree in valid.
   ///
   /// The demangler already catches most error cases and mostly produces valid
@@ -190,24 +195,24 @@ class NodePrinter {
   /// instead the NodePrinter bails.
   void setInvalid() { isValid = false; }
 
-  void printChildren(Node::iterator begin,
-                     Node::iterator end,
+  void printChildren(Node::iterator begin, Node::iterator end, unsigned depth,
                      const char *sep = nullptr) {
     for (; begin != end;) {
-      print(*begin);
+      print(*begin, depth + 1);
       ++begin;
       if (sep && begin != end)
         Printer << sep;
     }
   }
-  
-  void printChildren(NodePointer Node, const char *sep = nullptr) {
+
+  void printChildren(NodePointer Node, unsigned depth,
+                     const char *sep = nullptr) {
     if (!Node)
       return;
     Node::iterator begin = Node->begin(), end = Node->end();
-    printChildren(begin, end, sep);
+    printChildren(begin, end, depth, sep);
   }
-  
+
   NodePointer getFirstChildOfKind(NodePointer Node, Node::Kind kind) {
     if (!Node)
       return nullptr;
@@ -218,13 +223,13 @@ class NodePrinter {
     return nullptr;
   }
 
-  void printBoundGenericNoSugar(NodePointer Node) {
+  void printBoundGenericNoSugar(NodePointer Node, unsigned depth) {
     if (Node->getNumChildren() < 2)
       return;
     NodePointer typelist = Node->getChild(1);
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << "<";
-    printChildren(typelist, ", ");
+    printChildren(typelist, depth, ", ");
     Printer << ">";
   }
 
@@ -251,7 +256,7 @@ class NodePrinter {
         return Options.DisplayObjCModule;
       if (Context->getText() == Options.HidingCurrentModule)
         return false;
-      if (Context->getText().startswith(LLDB_EXPRESSIONS_MODULE_NAME_PREFIX))
+      if (Context->getText().starts_with(LLDB_EXPRESSIONS_MODULE_NAME_PREFIX))
         return Options.DisplayDebuggerGeneratedModule;
     }
     return true;
@@ -290,6 +295,7 @@ class NodePrinter {
     case Node::Kind::BoundGenericTypeAlias:
     case Node::Kind::BoundGenericFunction:
     case Node::Kind::BuiltinTypeName:
+    case Node::Kind::BuiltinTupleType:
     case Node::Kind::Class:
     case Node::Kind::DependentGenericType:
     case Node::Kind::DependentMemberType:
@@ -302,6 +308,11 @@ class NodePrinter {
     case Node::Kind::MetatypeRepresentation:
     case Node::Kind::Module:
     case Node::Kind::Tuple:
+    case Node::Kind::Pack:
+    case Node::Kind::SILPackDirect:
+    case Node::Kind::SILPackIndirect:
+    case Node::Kind::ConstrainedExistentialRequirementList:
+    case Node::Kind::ConstrainedExistentialSelf:
     case Node::Kind::Protocol:
     case Node::Kind::ProtocolSymbolicReference:
     case Node::Kind::ReturnType:
@@ -329,7 +340,12 @@ class NodePrinter {
     case Node::Kind::ProtocolListWithAnyObject:
       return Node->getChild(0)->getChild(0)->getNumChildren() == 0;
 
+    case Node::Kind::ConstrainedExistential:
+    case Node::Kind::PackElement:
+    case Node::Kind::PackElementLevel:
+    case Node::Kind::PackExpansion:
     case Node::Kind::ProtocolListWithClass:
+    case Node::Kind::AccessorAttachedMacroExpansion:
     case Node::Kind::AccessorFunctionReference:
     case Node::Kind::Allocator:
     case Node::Kind::ArgumentTuple:
@@ -337,12 +353,15 @@ class NodePrinter {
     case Node::Kind::AssociatedTypeDescriptor:
     case Node::Kind::AssociatedTypeMetadataAccessor:
     case Node::Kind::AssociatedTypeWitnessTableAccessor:
+    case Node::Kind::AsyncRemoved:
     case Node::Kind::AutoClosureType:
     case Node::Kind::BaseConformanceDescriptor:
     case Node::Kind::BaseWitnessTableAccessor:
+    case Node::Kind::BodyAttachedMacroExpansion:
     case Node::Kind::ClangType:
     case Node::Kind::ClassMetadataBaseOffset:
     case Node::Kind::CFunctionPointer:
+    case Node::Kind::ConformanceAttachedMacroExpansion:
     case Node::Kind::Constructor:
     case Node::Kind::CoroutineContinuationPrototype:
     case Node::Kind::CurryThunk:
@@ -354,10 +373,12 @@ class NodePrinter {
     case Node::Kind::DefaultAssociatedConformanceAccessor:
     case Node::Kind::DependentAssociatedTypeRef:
     case Node::Kind::DependentGenericSignature:
+    case Node::Kind::DependentGenericParamPackMarker:
     case Node::Kind::DependentGenericParamCount:
     case Node::Kind::DependentGenericConformanceRequirement:
     case Node::Kind::DependentGenericLayoutRequirement:
     case Node::Kind::DependentGenericSameTypeRequirement:
+    case Node::Kind::DependentGenericSameShapeRequirement:
     case Node::Kind::DependentPseudogenericSignature:
     case Node::Kind::Destructor:
     case Node::Kind::DidSet:
@@ -369,8 +390,10 @@ class NodePrinter {
     case Node::Kind::NoEscapeFunctionType:
     case Node::Kind::ExplicitClosure:
     case Node::Kind::Extension:
+    case Node::Kind::ExtensionAttachedMacroExpansion:
     case Node::Kind::EnumCase:
     case Node::Kind::FieldOffset:
+    case Node::Kind::FreestandingMacroExpansion:
     case Node::Kind::FullObjCResilientClassStub:
     case Node::Kind::FullTypeMetadata:
     case Node::Kind::Function:
@@ -396,12 +419,16 @@ class NodePrinter {
     case Node::Kind::GlobalGetter:
     case Node::Kind::Identifier:
     case Node::Kind::Index:
+    case Node::Kind::InitAccessor:
     case Node::Kind::IVarInitializer:
     case Node::Kind::IVarDestroyer:
     case Node::Kind::ImplDifferentiabilityKind:
     case Node::Kind::ImplEscaping:
+    case Node::Kind::ImplErasedIsolation:
+    case Node::Kind::ImplSendingResult:
     case Node::Kind::ImplConvention:
     case Node::Kind::ImplParameterResultDifferentiability:
+    case Node::Kind::ImplParameterSending:
     case Node::Kind::ImplFunctionAttribute:
     case Node::Kind::ImplFunctionConvention:
     case Node::Kind::ImplFunctionConventionName:
@@ -417,6 +444,8 @@ class NodePrinter {
     case Node::Kind::InfixOperator:
     case Node::Kind::Initializer:
     case Node::Kind::Isolated:
+    case Node::Kind::Sending:
+    case Node::Kind::CompileTimeConst:
     case Node::Kind::PropertyWrapperBackingInitializer:
     case Node::Kind::PropertyWrapperInitFromProjectedValue:
     case Node::Kind::KeyPathGetterThunkHelper:
@@ -426,7 +455,12 @@ class NodePrinter {
     case Node::Kind::LazyProtocolWitnessTableAccessor:
     case Node::Kind::LazyProtocolWitnessTableCacheVariable:
     case Node::Kind::LocalDeclName:
+    case Node::Kind::Macro:
+    case Node::Kind::MacroExpansionLoc:
+    case Node::Kind::MacroExpansionUniqueName:
     case Node::Kind::MaterializeForSet:
+    case Node::Kind::MemberAttributeAttachedMacroExpansion:
+    case Node::Kind::MemberAttachedMacroExpansion:
     case Node::Kind::MergedFunction:
     case Node::Kind::Metaclass:
     case Node::Kind::MethodDescriptor:
@@ -437,6 +471,7 @@ class NodePrinter {
     case Node::Kind::NativePinningAddressor:
     case Node::Kind::NativePinningMutableAddressor:
     case Node::Kind::NominalTypeDescriptor:
+    case Node::Kind::NominalTypeDescriptorRecord:
     case Node::Kind::NonObjCAttribute:
     case Node::Kind::Number:
     case Node::Kind::ObjCAsyncCompletionHandlerImpl:
@@ -445,6 +480,7 @@ class NodePrinter {
     case Node::Kind::ObjCMetadataUpdateFunction:
     case Node::Kind::ObjCResilientClassStub:
     case Node::Kind::OpaqueTypeDescriptor:
+    case Node::Kind::OpaqueTypeDescriptorRecord:
     case Node::Kind::OpaqueTypeDescriptorAccessor:
     case Node::Kind::OpaqueTypeDescriptorAccessorImpl:
     case Node::Kind::OpaqueTypeDescriptorAccessorKey:
@@ -454,15 +490,19 @@ class NodePrinter {
     case Node::Kind::OwningMutableAddressor:
     case Node::Kind::PartialApplyForwarder:
     case Node::Kind::PartialApplyObjCForwarder:
+    case Node::Kind::PeerAttachedMacroExpansion:
     case Node::Kind::PostfixOperator:
+    case Node::Kind::PreambleAttachedMacroExpansion:
     case Node::Kind::PredefinedObjCAsyncCompletionHandlerImpl:
     case Node::Kind::PrefixOperator:
     case Node::Kind::PrivateDeclName:
     case Node::Kind::PropertyDescriptor:
     case Node::Kind::ProtocolConformance:
     case Node::Kind::ProtocolConformanceDescriptor:
+    case Node::Kind::ProtocolConformanceDescriptorRecord:
     case Node::Kind::MetadataInstantiationCache:
     case Node::Kind::ProtocolDescriptor:
+    case Node::Kind::ProtocolDescriptorRecord:
     case Node::Kind::ProtocolRequirementsBaseDescriptor:
     case Node::Kind::ProtocolSelfConformanceDescriptor:
     case Node::Kind::ProtocolSelfConformanceWitness:
@@ -484,6 +524,7 @@ class NodePrinter {
     case Node::Kind::SILBoxMutableField:
     case Node::Kind::SILBoxImmutableField:
     case Node::Kind::IsSerialized:
+    case Node::Kind::MetatypeParamsRemoved:
     case Node::Kind::SpecializationPassID:
     case Node::Kind::Static:
     case Node::Kind::Subscript:
@@ -521,8 +562,11 @@ class NodePrinter {
     case Node::Kind::ConcurrentFunctionType:
     case Node::Kind::DifferentiableFunctionType:
     case Node::Kind::GlobalActorFunctionType:
+    case Node::Kind::IsolatedAnyFunctionType:
+    case Node::Kind::SendingResultFunctionType:
     case Node::Kind::AsyncAnnotation:
     case Node::Kind::ThrowsAnnotation:
+    case Node::Kind::TypedThrowsAnnotation:
     case Node::Kind::EmptyList:
     case Node::Kind::FirstElementMarker:
     case Node::Kind::VariadicMarker:
@@ -536,7 +580,15 @@ class NodePrinter {
     case Node::Kind::OutlinedAssignWithTake:
     case Node::Kind::OutlinedAssignWithCopy:
     case Node::Kind::OutlinedDestroy:
+    case Node::Kind::OutlinedInitializeWithCopyNoValueWitness:
+    case Node::Kind::OutlinedAssignWithTakeNoValueWitness:
+    case Node::Kind::OutlinedAssignWithCopyNoValueWitness:
+    case Node::Kind::OutlinedDestroyNoValueWitness:
+    case Node::Kind::OutlinedEnumTagStore:
+    case Node::Kind::OutlinedEnumGetTag:
+    case Node::Kind::OutlinedEnumProjectDataForLoad:
     case Node::Kind::OutlinedVariable:
+    case Node::Kind::OutlinedReadOnlyObject:
     case Node::Kind::AssocTypePath:
     case Node::Kind::ModuleDescriptor:
     case Node::Kind::AnonymousDescriptor:
@@ -545,6 +597,7 @@ class NodePrinter {
     case Node::Kind::AnonymousContext:
     case Node::Kind::AnyProtocolConformanceList:
     case Node::Kind::ConcreteProtocolConformance:
+    case Node::Kind::PackProtocolConformance:
     case Node::Kind::DependentAssociatedConformance:
     case Node::Kind::DependentProtocolConformanceAssociated:
     case Node::Kind::DependentProtocolConformanceInherited:
@@ -552,12 +605,16 @@ class NodePrinter {
     case Node::Kind::ProtocolConformanceRefInTypeModule:
     case Node::Kind::ProtocolConformanceRefInProtocolModule:
     case Node::Kind::ProtocolConformanceRefInOtherModule:
+    case Node::Kind::DistributedThunk:
+    case Node::Kind::DistributedAccessor:
     case Node::Kind::DynamicallyReplaceableFunctionKey:
     case Node::Kind::DynamicallyReplaceableFunctionImpl:
     case Node::Kind::DynamicallyReplaceableFunctionVar:
     case Node::Kind::OpaqueType:
     case Node::Kind::OpaqueTypeDescriptorSymbolicReference:
     case Node::Kind::OpaqueReturnType:
+    case Node::Kind::OpaqueReturnTypeIndex:
+    case Node::Kind::OpaqueReturnTypeParent:
     case Node::Kind::OpaqueReturnTypeOf:
     case Node::Kind::CanonicalSpecializedGenericMetaclass:
     case Node::Kind::CanonicalSpecializedGenericTypeMetadataAccessFunction:
@@ -578,16 +635,29 @@ class NodePrinter {
     case Node::Kind::IndexSubset:
     case Node::Kind::AsyncAwaitResumePartialFunction:
     case Node::Kind::AsyncSuspendResumePartialFunction:
+    case Node::Kind::AccessibleFunctionRecord:
+    case Node::Kind::BackDeploymentThunk:
+    case Node::Kind::BackDeploymentFallback:
+    case Node::Kind::ExtendedExistentialTypeShape:
+    case Node::Kind::Uniquable:
+    case Node::Kind::UniqueExtendedExistentialTypeShapeSymbolicReference:
+    case Node::Kind::NonUniqueExtendedExistentialTypeShapeSymbolicReference:
+    case Node::Kind::SymbolicExtendedExistentialType:
+    case Node::Kind::HasSymbolQuery:
+    case Node::Kind::ObjectiveCProtocolSymbolicReference:
+    case Node::Kind::ParamLifetimeDependence:
+    case Node::Kind::SelfLifetimeDependence:
+    case Node::Kind::DependentGenericInverseConformanceRequirement:
       return false;
     }
     printer_unreachable("bad node kind");
   }
 
-  void printWithParens(NodePointer type) {
+  void printWithParens(NodePointer type, unsigned depth) {
     bool needs_parens = !isSimpleType(type);
     if (needs_parens)
       Printer << "(";
-    print(type);
+    print(type, depth + 1);
     if (needs_parens)
       Printer << ")";
   }
@@ -644,12 +714,12 @@ class NodePrinter {
 
     return SugarType::None;
   }
-  
-  void printBoundGeneric(NodePointer Node) {
+
+  void printBoundGeneric(NodePointer Node, unsigned depth) {
     if (Node->getNumChildren() < 2)
       return;
     if (Node->getNumChildren() != 2) {
-      printBoundGenericNoSugar(Node);
+      printBoundGenericNoSugar(Node, depth);
       return;
     }
 
@@ -657,16 +727,16 @@ class NodePrinter {
         Node->getKind() == Node::Kind::BoundGenericClass)
     {
       // no sugar here
-      printBoundGenericNoSugar(Node);
+      printBoundGenericNoSugar(Node, depth);
       return;
     }
 
     // Print the conforming type for a "bound" protocol node "as" the protocol
     // type.
     if (Node->getKind() == Node::Kind::BoundGenericProtocol) {
-      printChildren(Node->getChild(1));
+      printChildren(Node->getChild(1), depth);
       Printer << " as ";
-      print(Node->getChild(0));
+      print(Node->getChild(0), depth + 1);
       return;
     }
 
@@ -674,19 +744,19 @@ class NodePrinter {
     
     switch (sugarType) {
       case SugarType::None:
-        printBoundGenericNoSugar(Node);
+        printBoundGenericNoSugar(Node, depth);
         break;
       case SugarType::Optional:
       case SugarType::ImplicitlyUnwrappedOptional: {
         NodePointer type = Node->getChild(1)->getChild(0);
-        printWithParens(type);
+        printWithParens(type, depth);
         Printer << (sugarType == SugarType::Optional ? "?" : "!");
         break;
       }
       case SugarType::Array: {
         NodePointer type = Node->getChild(1)->getChild(0);
         Printer << "[";
-        print(type);
+        print(type, depth + 1);
         Printer << "]";
         break;
       }
@@ -694,9 +764,9 @@ class NodePrinter {
         NodePointer keyType = Node->getChild(1)->getChild(0);
         NodePointer valueType = Node->getChild(1)->getChild(1);
         Printer << "[";
-        print(keyType);
+        print(keyType, depth + 1);
         Printer << " : ";
-        print(valueType);
+        print(valueType, depth + 1);
         Printer << "]";
         break;
       }
@@ -712,7 +782,7 @@ class NodePrinter {
   }
 
   void printFunctionParameters(NodePointer LabelList, NodePointer ParameterType,
-                               bool showTypes) {
+                               unsigned depth, bool showTypes) {
     if (ParameterType->getKind() != Node::Kind::ArgumentTuple) {
       setInvalid();
       return;
@@ -725,7 +795,7 @@ class NodePrinter {
       // only a single not-named parameter
       if (showTypes) {
         Printer << '(';
-        print(Parameters);
+        print(Parameters, depth + 1);
         Printer << ')';
       } else {
         Printer << "(_:)";
@@ -765,24 +835,25 @@ class NodePrinter {
           ++ParamIndex;
 
           if (showTypes)
-            print(Param);
+            print(Param, depth + 1);
         },
         [&]() { Printer << (showTypes ? ", " : ""); });
     Printer << ')';
   }
 
-  void printFunctionType(NodePointer LabelList, NodePointer node) {
-    if (node->getNumChildren() < 2 || node->getNumChildren() > 6) {
+  void printFunctionType(NodePointer LabelList, NodePointer node,
+                         unsigned depth) {
+    if (node->getNumChildren() < 2) {
       setInvalid();
       return;
     }
 
-    auto printConventionWithMangledCType = [this,
-                                            node](const char *convention) {
+    auto printConventionWithMangledCType = [this, node,
+                                            depth](const char *convention) {
       Printer << "@convention(" << convention;
       if (node->getFirstChild()->getKind() == Node::Kind::ClangType) {
         Printer << ", mangledCType: \"";
-        print(node->getFirstChild());
+        print(node->getFirstChild(), depth + 1);
         Printer << '"';
       }
       Printer << ") ";
@@ -811,12 +882,22 @@ class NodePrinter {
       assert(false && "Unhandled function type in printFunctionType!");
     }
 
+    unsigned argIndex = node->getNumChildren() - 2;
     unsigned startIndex = 0;
-    bool isSendable = false, isAsync = false, isThrows = false;
+    bool isSendable = false, isAsync = false, hasSendingResult = false;
     auto diffKind = MangledDifferentiabilityKind::NonDifferentiable;
+    if (node->getChild(startIndex)->getKind() == Node::Kind::ClangType) {
+      // handled earlier
+      ++startIndex;
+    }
+    if (node->getChild(startIndex)->getKind()
+            == Node::Kind::IsolatedAnyFunctionType) {
+      print(node->getChild(startIndex), depth + 1);
+      ++startIndex;
+    }
     if (node->getChild(startIndex)->getKind() ==
           Node::Kind::GlobalActorFunctionType) {
-      print(node->getChild(startIndex));
+      print(node->getChild(startIndex), depth + 1);
       ++startIndex;
     }
     if (node->getChild(startIndex)->getKind() ==
@@ -825,14 +906,20 @@ class NodePrinter {
           (MangledDifferentiabilityKind)node->getChild(startIndex)->getIndex();
       ++startIndex;
     }
-    if (node->getChild(startIndex)->getKind() == Node::Kind::ClangType) {
-      // handled earlier
+    if (node->getChild(startIndex)->getKind() ==
+        Node::Kind::SelfLifetimeDependence) {
+      print(node->getChild(startIndex), depth + 1);
       ++startIndex;
     }
-    if (node->getChild(startIndex)->getKind() == Node::Kind::ThrowsAnnotation) {
+
+    Node *thrownErrorNode = nullptr;
+    if (node->getChild(startIndex)->getKind() == Node::Kind::ThrowsAnnotation ||
+        node->getChild(startIndex)->getKind()
+          == Node::Kind::TypedThrowsAnnotation) {
+      thrownErrorNode = node->getChild(startIndex);
       ++startIndex;
-      isThrows = true;
     }
+
     if (node->getChild(startIndex)->getKind()
             == Node::Kind::ConcurrentFunctionType) {
       ++startIndex;
@@ -842,6 +929,11 @@ class NodePrinter {
       ++startIndex;
       isAsync = true;
     }
+    if (node->getChild(startIndex)->getKind() ==
+        Node::Kind::SendingResultFunctionType) {
+      ++startIndex;
+      hasSendingResult = true;
+    }
 
     switch (diffKind) {
     case MangledDifferentiabilityKind::Forward:
@@ -864,7 +956,7 @@ class NodePrinter {
       Printer << "@Sendable ";
 
     if (Options.ShowFunctionArgumentTypes) {
-      printFunctionParameters(LabelList, node->getChild(startIndex), true);
+      printFunctionParameters(LabelList, node->getChild(argIndex), depth, true);
     }
 
     if (!Options.ShowFunctionReturnType)
@@ -873,15 +965,22 @@ class NodePrinter {
     if (isAsync)
       Printer << " async";
 
-    if (isThrows)
-      Printer << " throws";
+    if (thrownErrorNode) {
+      print(thrownErrorNode, depth + 1);
+    }
 
-    print(node->getChild(startIndex + 1));
+    Printer << " -> ";
+
+    if (hasSendingResult)
+      Printer << "sending ";
+
+    print(node->getChild(argIndex + 1), depth + 1);
   }
 
-  void printImplFunctionType(NodePointer fn) {
+  void printImplFunctionType(NodePointer fn, unsigned depth) {
     NodePointer patternSubs = nullptr;
     NodePointer invocationSubs = nullptr;
+    NodePointer sendingResult = nullptr;
     enum State { Attrs, Inputs, Results } curState = Attrs;
     auto transitionTo = [&](State newState) {
       assert(newState >= curState);
@@ -890,12 +989,19 @@ class NodePrinter {
         case Attrs:
           if (patternSubs) {
             Printer << "@substituted ";
-            print(patternSubs->getChild(0));
+            print(patternSubs->getChild(0), depth + 1);
             Printer << ' ';
           }
           Printer << '(';
           continue;
-        case Inputs: Printer << ") -> ("; continue;
+        case Inputs:
+          Printer << ") -> ";
+          if (sendingResult) {
+            print(sendingResult, depth + 1);
+            Printer << " ";
+          }
+          Printer << "(";
+          continue;
         case Results: printer_unreachable("no state after Results");
         }
         printer_unreachable("bad state");
@@ -906,20 +1012,22 @@ class NodePrinter {
       if (child->getKind() == Node::Kind::ImplParameter) {
         if (curState == Inputs) Printer << ", ";
         transitionTo(Inputs);
-        print(child);
+        print(child, depth + 1);
       } else if (child->getKind() == Node::Kind::ImplResult
                  || child->getKind() == Node::Kind::ImplYield
                  || child->getKind() == Node::Kind::ImplErrorResult) {
         if (curState == Results) Printer << ", ";
         transitionTo(Results);
-        print(child);
+        print(child, depth + 1);
       } else if (child->getKind() == Node::Kind::ImplPatternSubstitutions) {
         patternSubs = child;
       } else if (child->getKind() == Node::Kind::ImplInvocationSubstitutions) {
         invocationSubs = child;
+      } else if (child->getKind() == Node::Kind::ImplSendingResult) {
+        sendingResult = child;
       } else {
         assert(curState == Attrs);
-        print(child);
+        print(child, depth + 1);
         Printer << ' ';
       }
     }
@@ -928,30 +1036,119 @@ class NodePrinter {
 
     if (patternSubs) {
       Printer << " for <";
-      printChildren(patternSubs->getChild(1));
+      printChildren(patternSubs->getChild(1), depth);
       Printer << '>';
     }
     if (invocationSubs) {
       Printer << " for <";
-      printChildren(invocationSubs->getChild(0));
+      printChildren(invocationSubs->getChild(0), depth);
       Printer << '>';
     }
   }
 
-  void printFunctionSigSpecializationParams(NodePointer Node);
+  void printGenericSignature(NodePointer Node, unsigned depth) {
+    Printer << '<';
+
+    unsigned numChildren = Node->getNumChildren();
+
+    unsigned numGenericParams = 0;
+    for (; numGenericParams < numChildren; ++numGenericParams) {
+      if (Node->getChild(numGenericParams)->getKind()
+               != Node::Kind::DependentGenericParamCount) {
+        break;
+      }
+    }
+
+    unsigned firstRequirement = numGenericParams;
+    for (; firstRequirement < numChildren; ++firstRequirement) {
+      auto child = Node->getChild(firstRequirement);
+      if (child->getKind() == Node::Kind::Type)
+        child = child->getChild(0);
+      if (child->getKind() != Node::Kind::DependentGenericParamPackMarker) {
+        break;
+      }
+    }
+
+    auto isGenericParamPack = [&](unsigned depth, unsigned index) {
+      for (unsigned i = numGenericParams; i < firstRequirement; ++i) {
+        auto child = Node->getChild(i);
+        if (child->getKind() != Node::Kind::DependentGenericParamPackMarker)
+          continue;
+        child = child->getChild(0);
+
+        if (child->getKind() != Node::Kind::Type)
+          continue;
+
+        child = child->getChild(0);
+        if (child->getKind() != Node::Kind::DependentGenericParamType)
+          continue;
+
+        if (index == child->getChild(0)->getIndex() &&
+            depth == child->getChild(1)->getIndex()) {
+          return true;
+        }
+      }
+
+      return false;
+    };
+
+    unsigned gpDepth = 0;
+    for (; gpDepth < numGenericParams; ++gpDepth) {
+      if (gpDepth != 0)
+        Printer << "><";
+
+      unsigned count = Node->getChild(gpDepth)->getIndex();
+      for (unsigned index = 0; index < count; ++index) {
+        if (index != 0)
+          Printer << ", ";
+
+        // Limit the number of printed generic parameters. In practice this
+        // it will never be exceeded. The limit is only important for malformed
+        // symbols where count can be really huge.
+        if (index >= 128) {
+          Printer << "...";
+          break;
+        }
+
+        if (isGenericParamPack(gpDepth, index))
+          Printer << "each ";
+
+        // FIXME: Depth won't match when a generic signature applies to a
+        // method in generic type context.
+        Printer << Options.GenericParameterName(gpDepth, index);
+      }
+    }
+
+    if (firstRequirement != numChildren) {
+      if (Options.DisplayWhereClauses) {
+        Printer << " where ";
+        for (unsigned i = firstRequirement; i < numChildren; ++i) {
+          if (i > firstRequirement)
+            Printer << ", ";
+          print(Node->getChild(i), depth + 1);
+        }
+      }
+    }
+    Printer << '>';
+  }
+
+  void printFunctionSigSpecializationParams(NodePointer Node, unsigned depth);
 
   void printSpecializationPrefix(NodePointer node, StringRef Description,
+                                 unsigned depth,
                                  StringRef ParamPrefix = StringRef());
 
   /// The main big print function.
-  NodePointer print(NodePointer Node, bool asPrefixContext = false);
+  NodePointer print(NodePointer Node, unsigned depth,
+                    bool asPrefixContext = false);
 
-  NodePointer printAbstractStorage(NodePointer Node, bool asPrefixContent,
-                                   StringRef ExtraName);
+  NodePointer printAbstractStorage(NodePointer Node, unsigned depth,
+                                   bool asPrefixContent, StringRef ExtraName);
 
   /// Utility function to print entities.
   ///
   /// \param Entity The entity node to print
+  /// \param depth The depth in the print() call tree.
   /// \param asPrefixContext Should the entity printed as a context which as a
   ///        prefix to another entity, e.g. the Abc in Abc.def()
   /// \param TypePr How should the type of the entity be printed, if at all.
@@ -965,10 +1162,10 @@ class NodePrinter {
   ///        provided by the node. Gets printed even if hasName is false.
   /// \return If a non-null node is returned it's a context which must be
   ///         printed in postfix-form after the entity: "<entity> in <context>".
-  NodePointer printEntity(NodePointer Entity, bool asPrefixContext,
-                          TypePrinting TypePr, bool hasName,
-                          StringRef ExtraName = "", int ExtraIndex = -1,
-                          StringRef OverwriteName = "");
+  NodePointer printEntity(NodePointer Entity, unsigned depth,
+                          bool asPrefixContext, TypePrinting TypePr,
+                          bool hasName, StringRef ExtraName = "",
+                          int ExtraIndex = -1, StringRef OverwriteName = "");
 
   /// Print the type of an entity.
   ///
@@ -976,9 +1173,9 @@ class NodePrinter {
   /// \param type The type of the entity.
   /// \param genericFunctionTypeList If not null, the generic argument types
   ///           which is printed in the generic signature.
+  /// \param depth The depth in the print() call tree.
   void printEntityType(NodePointer Entity, NodePointer type,
-                       NodePointer genericFunctionTypeList);
-
+                       NodePointer genericFunctionTypeList, unsigned depth);
 };
 } // end anonymous namespace
 
@@ -990,7 +1187,8 @@ static bool isExistentialType(NodePointer node) {
 }
 
 /// Print the relevant parameters and return the new index.
-void NodePrinter::printFunctionSigSpecializationParams(NodePointer Node) {
+void NodePrinter::printFunctionSigSpecializationParams(NodePointer Node,
+                                                       unsigned depth) {
   unsigned Idx = 0;
   unsigned End = Node->getNumChildren();
   while (Idx < End) {
@@ -1000,12 +1198,13 @@ void NodePrinter::printFunctionSigSpecializationParams(NodePointer Node) {
     switch (K) {
     case FunctionSigSpecializationParamKind::BoxToValue:
     case FunctionSigSpecializationParamKind::BoxToStack:
-      print(Node->getChild(Idx++));
+    case FunctionSigSpecializationParamKind::InOutToOut:
+      print(Node->getChild(Idx++), depth + 1);
       break;
     case FunctionSigSpecializationParamKind::ConstantPropFunction:
     case FunctionSigSpecializationParamKind::ConstantPropGlobal: {
       Printer << "[";
-      print(Node->getChild(Idx++));
+      print(Node->getChild(Idx++), depth + 1);
       Printer << " : ";
       const auto &text = Node->getChild(Idx++)->getText();
       std::string demangledName = demangleSymbolAsString(text);
@@ -1020,33 +1219,44 @@ void NodePrinter::printFunctionSigSpecializationParams(NodePointer Node) {
     case FunctionSigSpecializationParamKind::ConstantPropInteger:
     case FunctionSigSpecializationParamKind::ConstantPropFloat:
       Printer << "[";
-      print(Node->getChild(Idx++));
+      print(Node->getChild(Idx++), depth + 1);
       Printer << " : ";
-      print(Node->getChild(Idx++));
+      print(Node->getChild(Idx++), depth + 1);
       Printer << "]";
       break;
     case FunctionSigSpecializationParamKind::ConstantPropString:
       Printer << "[";
-      print(Node->getChild(Idx++));
+      print(Node->getChild(Idx++), depth + 1);
       Printer << " : ";
-      print(Node->getChild(Idx++));
+      print(Node->getChild(Idx++), depth + 1);
       Printer << "'";
-      print(Node->getChild(Idx++));
+      print(Node->getChild(Idx++), depth + 1);
       Printer << "'";
       Printer << "]";
       break;
+    case FunctionSigSpecializationParamKind::ConstantPropKeyPath:
+      Printer << "[";
+      print(Node->getChild(Idx++), depth + 1);
+      Printer << " : ";
+      print(Node->getChild(Idx++), depth + 1);
+      Printer << "<";
+      print(Node->getChild(Idx++), depth + 1);
+      Printer << ",";
+      print(Node->getChild(Idx++), depth + 1);
+      Printer << ">]";
+      break;
     case FunctionSigSpecializationParamKind::ClosureProp:
       Printer << "[";
-      print(Node->getChild(Idx++));
+      print(Node->getChild(Idx++), depth + 1);
       Printer << " : ";
-      print(Node->getChild(Idx++));
+      print(Node->getChild(Idx++), depth + 1);
       Printer << ", Argument Types : [";
       for (unsigned e = Node->getNumChildren(); Idx < e;) {
         NodePointer child = Node->getChild(Idx);
         // Until we no longer have a type node, keep demangling.
         if (child->getKind() != Node::Kind::Type)
           break;
-        print(child);
+        print(child, depth + 1);
         ++Idx;
 
         // If we are not done, print the ", ".
@@ -1064,13 +1274,14 @@ void NodePrinter::printFunctionSigSpecializationParams(NodePointer Node) {
         (V & unsigned(
                   FunctionSigSpecializationParamKind::ExistentialToGeneric))) &&
        "Invalid OptionSet");
-      print(Node->getChild(Idx++));
+      print(Node->getChild(Idx++), depth + 1);
     }
   }
 }
 
 void NodePrinter::printSpecializationPrefix(NodePointer node,
                                             StringRef Description,
+                                            unsigned depth,
                                             StringRef ParamPrefix) {
   if (!Options.DisplayGenericSpecializations) {
     if (!SpecializationPrefixPrinted) {
@@ -1085,14 +1296,15 @@ void NodePrinter::printSpecializationPrefix(NodePointer node,
   for (NodePointer child : *node) {
     switch (child->getKind()) {
       case Node::Kind::SpecializationPassID:
-        // We skip the SpecializationPassID since it does not contain any
+      case Node::Kind::MetatypeParamsRemoved:
+        // We skip those nodes since it does not contain any
         // information that is useful to our users.
         break;
 
       case Node::Kind::IsSerialized:
         Printer << Separator;
         Separator = ", ";
-        print(child);
+        print(child, depth + 1);
         break;
 
       default:
@@ -1103,14 +1315,14 @@ void NodePrinter::printSpecializationPrefix(NodePointer node,
           switch (child->getKind()) {
           case Node::Kind::FunctionSignatureSpecializationParam:
             Printer << "Arg[" << argNum << "] = ";
-            printFunctionSigSpecializationParams(child);
+            printFunctionSigSpecializationParams(child, depth);
             break;
           case Node::Kind::FunctionSignatureSpecializationReturn:
             Printer << "Return = ";
-            printFunctionSigSpecializationParams(child);
+            printFunctionSigSpecializationParams(child, depth);
             break;
           default:
-            print(child);
+            print(child, depth + 1);
           }
         }
         ++argNum;
@@ -1138,99 +1350,150 @@ static bool needSpaceBeforeType(NodePointer Type) {
   }
 }
 
-NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
+/// Determine whether to print an entity's type.
+static bool shouldShowEntityType(Node::Kind EntityKind,
+                                 const DemangleOptions &Options) {
+  switch (EntityKind) {
+  case Node::Kind::ExplicitClosure:
+  case Node::Kind::ImplicitClosure:
+    // The signature of a closure (its `Type` node) can optionally be omitted.
+    // Unlike functions which can have overloads, the signature of a closure is
+    // not needed to be uniquely identified. A closure is uniquely identified by
+    // its index and parent. Omitting the signature improves the readability
+    // when long type names are in use.
+    return Options.ShowClosureSignature;
+  default:
+    return true;
+  }
+}
+
+NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
+                               bool asPrefixContext) {
+  if (depth > NodePrinter::MaxDepth) {
+    Printer << "<<too complex>>";
+    return nullptr;
+  }
+
+  if (!Node) {
+    Printer << "<null node pointer>";
+    return nullptr;
+  }
+
   switch (auto kind = Node->getKind()) {
   case Node::Kind::Static:
     Printer << "static ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::AsyncRemoved:
+    Printer << "async demotion of ";
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::CurryThunk:
     Printer << "curry thunk of ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::DispatchThunk:
     Printer << "dispatch thunk of ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::MethodDescriptor:
     Printer << "method descriptor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::MethodLookupFunction:
     Printer << "method lookup function for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::ObjCMetadataUpdateFunction:
     Printer << "ObjC metadata update function for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::ObjCResilientClassStub:
     Printer << "ObjC resilient class stub for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::FullObjCResilientClassStub:
     Printer << "full ObjC resilient class stub for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OutlinedBridgedMethod:
     Printer << "outlined bridged method (" << Node->getText() << ") of ";
     return nullptr;
   case Node::Kind::OutlinedCopy:
     Printer << "outlined copy of ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     if (Node->getNumChildren() > 1)
-      print(Node->getChild(1));
+      print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::OutlinedConsume:
     Printer << "outlined consume of ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     if (Node->getNumChildren() > 1)
-      print(Node->getChild(1));
+      print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::OutlinedRetain:
     Printer << "outlined retain of ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OutlinedRelease:
     Printer << "outlined release of ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OutlinedInitializeWithTake:
     Printer << "outlined init with take of ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OutlinedInitializeWithCopy:
+  case Node::Kind::OutlinedInitializeWithCopyNoValueWitness:
     Printer << "outlined init with copy of ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OutlinedAssignWithTake:
+  case Node::Kind::OutlinedAssignWithTakeNoValueWitness:
     Printer << "outlined assign with take of ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OutlinedAssignWithCopy:
+  case Node::Kind::OutlinedAssignWithCopyNoValueWitness:
     Printer << "outlined assign with copy of ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OutlinedDestroy:
+  case Node::Kind::OutlinedDestroyNoValueWitness:
     Printer << "outlined destroy of ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::OutlinedEnumProjectDataForLoad:
+    Printer << "outlined enum project data for load of ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::OutlinedEnumTagStore:
+    Printer << "outlined enum tag store of ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::OutlinedEnumGetTag:
+    Printer << "outlined enum get tag of ";
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OutlinedVariable:
     Printer << "outlined variable #" << Node->getIndex() << " of ";
     return nullptr;
+  case Node::Kind::OutlinedReadOnlyObject:
+    Printer << "outlined read-only object #" << Node->getIndex() << " of ";
+    return nullptr;
   case Node::Kind::Directness:
     Printer << toString(Directness(Node->getIndex())) << " ";
     return nullptr;
   case Node::Kind::AnonymousContext:
     if (Options.QualifyEntities && Options.DisplayExtensionContexts) {
-      print(Node->getChild(1));
+      print(Node->getChild(1), depth + 1);
       Printer << ".(unknown context at ";
-      print(Node->getChild(0));
+      print(Node->getChild(0), depth + 1);
       Printer << ")";
       if (Node->getNumChildren() >= 3 &&
           Node->getChild(2)->getNumChildren() > 0) {
         Printer << '<';
-        print(Node->getChild(2));
+        print(Node->getChild(2), depth + 1);
         Printer << '>';
       }
     }
@@ -1241,45 +1504,87 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     if (Options.QualifyEntities && Options.DisplayExtensionContexts) {
       Printer << "(extension in ";
       // Print the module where extension is defined.
-      print(Node->getChild(0), true);
+      print(Node->getChild(0), depth + 1, true);
       Printer << "):";
     }
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     if (Node->getNumChildren() == 3) {
       // Currently the runtime does not mangle the generic signature.
       // This is an open to-do in swift::_buildDemanglingForContext().
       if (!Options.PrintForTypeName)
-        print(Node->getChild(2));
+        print(Node->getChild(2), depth + 1);
     }
     return nullptr;
   case Node::Kind::Variable:
-    return printEntity(Node, asPrefixContext, TypePrinting::WithColon,
-                       /*hasName*/true);
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::WithColon,
+                       /*hasName*/ true);
   case Node::Kind::Function:
   case Node::Kind::BoundGenericFunction:
-    return printEntity(Node, asPrefixContext, TypePrinting::FunctionStyle,
-                       /*hasName*/true);
+    return printEntity(Node, depth, asPrefixContext,
+                       TypePrinting::FunctionStyle,
+                       /*hasName*/ true);
   case Node::Kind::Subscript:
-    return printEntity(Node, asPrefixContext, TypePrinting::FunctionStyle,
-                       /*hasName*/false, /*ExtraName*/"", /*ExtraIndex*/-1,
-                       "subscript");
+    return printEntity(
+        Node, depth, asPrefixContext, TypePrinting::FunctionStyle,
+        /*hasName*/ false, /*ExtraName*/ "", /*ExtraIndex*/ -1, "subscript");
+  case Node::Kind::Macro:
+    return printEntity(Node, depth, asPrefixContext,
+                       Node->getNumChildren() == 3? TypePrinting::WithColon
+                                                  : TypePrinting::FunctionStyle,
+                       /*hasName*/ true);
+#define FREESTANDING_MACRO_ROLE(Name, Description)
+#define ATTACHED_MACRO_ROLE(Name, Description, MangledChar)                \
+  case Node::Kind::Name##AttachedMacroExpansion:                           \
+    return printEntity(Node, depth, asPrefixContext,                       \
+                       TypePrinting::NoType, /*hasName*/true,              \
+                       (Description " macro @" +                           \
+                        nodeToString(Node->getChild(2)) + " expansion #"), \
+                       (int)Node->getChild(3)->getIndex() + 1);
+#include "swift/Basic/MacroRoles.def"
+  case Node::Kind::FreestandingMacroExpansion:
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/true, "freestanding macro expansion #",
+                       (int)Node->getChild(2)->getIndex() + 1);
+  case Node::Kind::MacroExpansionLoc:
+    if (Node->getNumChildren() > 0) {
+      Printer << "module ";
+      print(Node->getChild(0), depth + 1);
+    }
+    if (Node->getNumChildren() > 1) {
+      Printer << " file ";
+      print(Node->getChild(1), depth + 1);
+    }
+    if (Node->getNumChildren() > 2) {
+      Printer << " line ";
+      print(Node->getChild(2), depth + 1);
+    }
+    if (Node->getNumChildren() > 3) {
+      Printer << " column ";
+      print(Node->getChild(3), depth + 1);
+    }
+    return nullptr;
+  case Node::Kind::MacroExpansionUniqueName:
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/true, "unique name #",
+                       (int)Node->getChild(2)->getIndex() + 1);
   case Node::Kind::GenericTypeParamDecl:
-    return printEntity(Node, asPrefixContext, TypePrinting::NoType,
-                       /*hasName*/true);
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/ true);
   case Node::Kind::ExplicitClosure:
-    return printEntity(Node, asPrefixContext,
-                       Options.ShowFunctionArgumentTypes ?
-                         TypePrinting::FunctionStyle : TypePrinting::NoType,
-                       /*hasName*/false, "closure #",
-                       (int)Node->getChild(1)->getIndex() + 1);
+    return printEntity(
+        Node, depth, asPrefixContext,
+        Options.ShowFunctionArgumentTypes ? TypePrinting::FunctionStyle
+                                          : TypePrinting::NoType,
+        /*hasName*/ false, "closure #", (int)Node->getChild(1)->getIndex() + 1);
   case Node::Kind::ImplicitClosure:
-    return printEntity(Node, asPrefixContext,
-                       Options.ShowFunctionArgumentTypes ?
-                         TypePrinting::FunctionStyle : TypePrinting::NoType,
-                       /*hasName*/false, "implicit closure #",
+    return printEntity(Node, depth, asPrefixContext,
+                       Options.ShowFunctionArgumentTypes
+                           ? TypePrinting::FunctionStyle
+                           : TypePrinting::NoType,
+                       /*hasName*/ false, "implicit closure #",
                        (int)Node->getChild(1)->getIndex() + 1);
   case Node::Kind::Global:
-    printChildren(Node);
+    printChildren(Node, depth);
     return nullptr;
   case Node::Kind::Suffix:
     if (Options.DisplayUnmangledSuffix) {
@@ -1288,31 +1593,32 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     }
     return nullptr;
   case Node::Kind::Initializer:
-    return printEntity(Node, asPrefixContext, TypePrinting::NoType,
-                       /*hasName*/false, "variable initialization expression");
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/ false, "variable initialization expression");
   case Node::Kind::PropertyWrapperBackingInitializer:
-    return printEntity(
-         Node, asPrefixContext, TypePrinting::NoType,
-         /*hasName*/false, "property wrapper backing initializer");
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/ false,
+                       "property wrapper backing initializer");
   case Node::Kind::PropertyWrapperInitFromProjectedValue:
-    return printEntity(
-         Node, asPrefixContext, TypePrinting::NoType,
-         /*hasName*/false, "property wrapper init from projected value");
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/ false,
+                       "property wrapper init from projected value");
   case Node::Kind::DefaultArgumentInitializer:
-    return printEntity(Node, asPrefixContext, TypePrinting::NoType,
-                       /*hasName*/false, "default argument ",
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/ false, "default argument ",
                        (int)Node->getChild(1)->getIndex());
   case Node::Kind::DeclContext:
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::Type:
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::TypeMangling:
     if (Node->getChild(0)->getKind() == Node::Kind::LabelList) {
-      printFunctionType(Node->getChild(0), Node->getChild(1)->getFirstChild());
+      printFunctionType(Node->getChild(0), Node->getChild(1)->getFirstChild(),
+                        depth);
     } else {
-      print(Node->getChild(0));
+      print(Node->getChild(0), depth + 1);
     }
     return nullptr;
   case Node::Kind::Class:
@@ -1321,10 +1627,10 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::Protocol:
   case Node::Kind::TypeAlias:
   case Node::Kind::OtherNominalType:
-    return printEntity(Node, asPrefixContext, TypePrinting::NoType,
-                       /*hasName*/true);
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/ true);
   case Node::Kind::LocalDeclName:
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     if (Options.DisplayLocalNameContexts)
       Printer << " #" << (Node->getChild(0)->getIndex() + 1);
     return nullptr;
@@ -1333,7 +1639,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
       if (Options.ShowPrivateDiscriminators)
         Printer << '(';
 
-      print(Node->getChild(1));
+      print(Node->getChild(1), depth + 1);
 
       if (Options.ShowPrivateDiscriminators)
         Printer << " in " << Node->getChild(0)->getText() << ')';
@@ -1345,7 +1651,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     return nullptr;
   case Node::Kind::RelatedEntityDeclName:
     Printer << "related decl '" << Node->getFirstChild()->getText() << "' for ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::Module:
     if (Options.DisplayModuleNames)
@@ -1369,17 +1675,18 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::CFunctionPointer:
   case Node::Kind::ObjCBlock:
   case Node::Kind::EscapingObjCBlock:
-    printFunctionType(nullptr, Node);
+    printFunctionType(nullptr, Node, depth);
     return nullptr;
   case Node::Kind::ClangType:
     Printer << Node->getText();
     return nullptr;
   case Node::Kind::ArgumentTuple:
-    printFunctionParameters(nullptr, Node, Options.ShowFunctionArgumentTypes);
+    printFunctionParameters(nullptr, Node, depth,
+                            Options.ShowFunctionArgumentTypes);
     return nullptr;
   case Node::Kind::Tuple: {
     Printer << "(";
-    printChildren(Node, ", ");
+    printChildren(Node, depth, ", ");
     Printer << ")";
     return nullptr;
   }
@@ -1390,7 +1697,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     auto Type = getChildIf(Node, Node::Kind::Type);
     assert(Type && "malformed Node::Kind::TupleElement");
 
-    print(Type);
+    print(Type, depth + 1);
 
     if (getChildIf(Node, Node::Kind::VariadicMarker))
       Printer << "...";
@@ -1399,12 +1706,39 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::TupleElementName:
     Printer << Node->getText() << ": ";
     return nullptr;
+  case Node::Kind::Pack: {
+    Printer << "Pack{";
+    printChildren(Node, depth, ", ");
+    Printer << "}";
+    return nullptr;
+  }
+  case Node::Kind::SILPackDirect:
+  case Node::Kind::SILPackIndirect: {
+    Printer << (kind == Node::Kind::SILPackDirect ? "@direct" : "@indirect");
+    Printer << " Pack{";
+    printChildren(Node, depth, ", ");
+    Printer << "}";
+    return nullptr;
+  }
+  case Node::Kind::PackExpansion: {
+    Printer << "repeat ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  }
+  case Node::Kind::PackElement: {
+    Printer << "/* level: " << Node->getChild(1)->getIndex() << " */ ";
+    Printer << "each ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  }
+  case Node::Kind::PackElementLevel:
+    printer_unreachable("should be handled in Node::Kind::PackElement");
+
   case Node::Kind::ReturnType:
     if (Node->getNumChildren() == 0)
-      Printer << " -> " << Node->getText();
+      Printer << Node->getText();
     else {
-      Printer << " -> ";
-      printChildren(Node);
+      printChildren(Node, depth);
     }
     return nullptr;
   case Node::Kind::RetroactiveConformance:
@@ -1412,35 +1746,70 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
       return nullptr;
 
     Printer << "retroactive @ ";
-    print(Node->getChild(0));
-    print(Node->getChild(1));
+    print(Node->getChild(0), depth + 1);
+    print(Node->getChild(1), depth + 1);
     return nullptr;
-#define REF_STORAGE(Name, ...) \
-  case Node::Kind::Name: \
-    Printer << keywordOf(ReferenceOwnership::Name) << " "; \
-    print(Node->getChild(0)); \
+#define REF_STORAGE(Name, ...)                                                 \
+  case Node::Kind::Name:                                                       \
+    Printer << keywordOf(ReferenceOwnership::Name) << " ";                     \
+    print(Node->getChild(0), depth + 1);                                       \
     return nullptr;
 #include "swift/AST/ReferenceStorage.def"
   case Node::Kind::InOut:
     Printer << "inout ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::Isolated:
     Printer << "isolated ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::Sending:
+    Printer << "sending ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::CompileTimeConst:
+    Printer << "_const ";
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::Shared:
     Printer << "__shared ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::Owned:
     Printer << "__owned ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::NoDerivative:
     Printer << "@noDerivative ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::ParamLifetimeDependence: {
+    Printer << "lifetime dependence: ";
+    auto kind = (MangledLifetimeDependenceKind)Node->getChild(0)->getIndex();
+    switch (kind) {
+    case MangledLifetimeDependenceKind::Inherit:
+      Printer << "inherit ";
+      break;
+    case MangledLifetimeDependenceKind::Scope:
+      Printer << "scope ";
+      break;
+    }
+    print(Node->getChild(1), depth + 1);
     return nullptr;
+  }
+  case Node::Kind::SelfLifetimeDependence: {
+    Printer << "(self lifetime dependence: ";
+    auto kind = (MangledLifetimeDependenceKind)Node->getIndex();
+    switch (kind) {
+    case MangledLifetimeDependenceKind::Inherit:
+      Printer << "inherit) ";
+      break;
+    case MangledLifetimeDependenceKind::Scope:
+      Printer << "scope) ";
+      break;
+    }
+    return nullptr;
+  }
   case Node::Kind::NonObjCAttribute:
     Printer << "@nonobjc ";
     return nullptr;
@@ -1457,40 +1826,45 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     Printer << "override ";
     return nullptr;
   case Node::Kind::FunctionSignatureSpecialization:
-    printSpecializationPrefix(Node, "function signature specialization");
+    printSpecializationPrefix(Node, "function signature specialization", depth);
     return nullptr;
   case Node::Kind::GenericPartialSpecialization:
-    printSpecializationPrefix(Node, "generic partial specialization",
+    printSpecializationPrefix(Node, "generic partial specialization", depth,
                               "Signature = ");
     return nullptr;
   case Node::Kind::GenericPartialSpecializationNotReAbstracted:
     printSpecializationPrefix(Node,
-            "generic not-reabstracted partial specialization", "Signature = ");
+                              "generic not-reabstracted partial specialization",
+                              depth, "Signature = ");
     return nullptr;
   case Node::Kind::GenericSpecialization:
   case Node::Kind::GenericSpecializationInResilienceDomain:
-    printSpecializationPrefix(Node, "generic specialization");
+    printSpecializationPrefix(Node, "generic specialization", depth);
     return nullptr;
   case Node::Kind::GenericSpecializationPrespecialized:
-    printSpecializationPrefix(Node, "generic pre-specialization");
+    printSpecializationPrefix(Node, "generic pre-specialization", depth);
     return nullptr;
   case Node::Kind::GenericSpecializationNotReAbstracted:
-    printSpecializationPrefix(Node, "generic not re-abstracted specialization");
+    printSpecializationPrefix(Node, "generic not re-abstracted specialization",
+                              depth);
     return nullptr;
   case Node::Kind::InlinedGenericFunction:
-    printSpecializationPrefix(Node, "inlined generic function");
+    printSpecializationPrefix(Node, "inlined generic function", depth);
     return nullptr;
   case Node::Kind::IsSerialized:
     Printer << "serialized";
     return nullptr;
+  case Node::Kind::MetatypeParamsRemoved:
+    Printer << "metatypes-removed";
+    return nullptr;
   case Node::Kind::GenericSpecializationParam:
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     for (unsigned i = 1, e = Node->getNumChildren(); i < e; ++i) {
       if (i == 1)
         Printer << " with ";
       else
         Printer << " and ";
-      print(Node->getChild(i));
+      print(Node->getChild(i), depth + 1);
     }
     return nullptr;
   case Node::Kind::FunctionSignatureSpecializationReturn:
@@ -1552,6 +1926,9 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     case FunctionSigSpecializationParamKind::BoxToStack:
       Printer << "Stack Promoted from Box";
       return nullptr;
+    case FunctionSigSpecializationParamKind::InOutToOut:
+      Printer << "InOut Converted to Out";
+      return nullptr;
     case FunctionSigSpecializationParamKind::ConstantPropFunction:
       Printer << "Constant Propagated Function";
       return nullptr;
@@ -1567,6 +1944,9 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     case FunctionSigSpecializationParamKind::ConstantPropString:
       Printer << "Constant Propagated String";
       return nullptr;
+    case FunctionSigSpecializationParamKind::ConstantPropKeyPath:
+      Printer << "Constant Propagated KeyPath";
+      return nullptr;
     case FunctionSigSpecializationParamKind::ClosureProp:
       Printer << "Closure Propagated";
       return nullptr;
@@ -1585,6 +1965,9 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::BuiltinTypeName:
     Printer << Node->getText();
     return nullptr;
+  case Node::Kind::BuiltinTupleType:
+    Printer << "Builtin.TheTupleType";
+    return nullptr;
   case Node::Kind::Number:
     Printer << Node->getIndex();
     return nullptr;
@@ -1599,61 +1982,61 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     return nullptr;
   case Node::Kind::LazyProtocolWitnessTableAccessor:
     Printer << "lazy protocol witness table accessor for type ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << " and conformance ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::LazyProtocolWitnessTableCacheVariable:
     Printer << "lazy protocol witness table cache variable for type ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << " and conformance ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::ProtocolSelfConformanceWitnessTable:
     Printer << "protocol self-conformance witness table for ";
-    print(Node->getFirstChild());
+    print(Node->getFirstChild(), depth + 1);
     return nullptr;
   case Node::Kind::ProtocolWitnessTableAccessor:
     Printer << "protocol witness table accessor for ";
-    print(Node->getFirstChild());
+    print(Node->getFirstChild(), depth + 1);
     return nullptr;
   case Node::Kind::ProtocolWitnessTable:
     Printer << "protocol witness table for ";
-    print(Node->getFirstChild());
+    print(Node->getFirstChild(), depth + 1);
     return nullptr;
   case Node::Kind::ProtocolWitnessTablePattern:
     Printer << "protocol witness table pattern for ";
-    print(Node->getFirstChild());
+    print(Node->getFirstChild(), depth + 1);
     return nullptr;
   case Node::Kind::GenericProtocolWitnessTable:
     Printer << "generic protocol witness table for ";
-    print(Node->getFirstChild());
+    print(Node->getFirstChild(), depth + 1);
     return nullptr;
   case Node::Kind::GenericProtocolWitnessTableInstantiationFunction:
     Printer << "instantiation function for generic protocol witness table for ";
-    print(Node->getFirstChild());
+    print(Node->getFirstChild(), depth + 1);
     return nullptr;
   case Node::Kind::ResilientProtocolWitnessTable:
     Printer << "resilient protocol witness table for ";
-    print(Node->getFirstChild());
+    print(Node->getFirstChild(), depth + 1);
     return nullptr;
   case Node::Kind::VTableThunk: {
     Printer << "vtable thunk for ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     Printer << " dispatching to ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   }
   case Node::Kind::ProtocolSelfConformanceWitness: {
     Printer << "protocol self-conformance witness for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   }
   case Node::Kind::ProtocolWitness: {
     Printer << "protocol witness for ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     Printer << " in conformance ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   }
   case Node::Kind::PartialApplyForwarder:
@@ -1664,7 +2047,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
 
     if (Node->hasChildren()) {
       Printer << " for ";
-      printChildren(Node);
+      printChildren(Node, depth);
     }
     return nullptr;
   case Node::Kind::PartialApplyObjCForwarder:
@@ -1675,7 +2058,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
 
     if (Node->hasChildren()) {
       Printer << " for ";
-      printChildren(Node);
+      printChildren(Node, depth);
     }
     return nullptr;
   case Node::Kind::KeyPathGetterThunkHelper:
@@ -1685,13 +2068,13 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     else
       Printer << "key path setter for ";
 
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << " : ";
     for (unsigned index = 1; index < Node->getNumChildren(); ++index) {
       auto Child = Node->getChild(index);
       if (Child->getKind() == Node::Kind::IsSerialized)
         Printer << ", ";
-      print(Child);
+      print(Child, depth + 1);
     }
     return nullptr;
   case Node::Kind::KeyPathEqualsThunkHelper:
@@ -1703,15 +2086,13 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
 
     unsigned lastChildIndex = Node->getNumChildren();
     auto lastChild = Node->getChild(lastChildIndex - 1);
-    bool isSerialized = false;
     if (lastChild->getKind() == Node::Kind::IsSerialized) {
-      isSerialized = true;
       --lastChildIndex;
       lastChild = Node->getChild(lastChildIndex - 1);
     }
 
     if (lastChild->getKind() == Node::Kind::DependentGenericSignature) {
-      print(lastChild);
+      print(lastChild, depth + 1);
       --lastChildIndex;
     }
 
@@ -1719,29 +2100,29 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     for (unsigned i = 0; i < lastChildIndex; ++i) {
       if (i != 0)
         Printer << ", ";
-      print(Node->getChild(i));
+      print(Node->getChild(i), depth + 1);
     }
     Printer << ")";
     return nullptr;
   }
   case Node::Kind::FieldOffset: {
-    print(Node->getChild(0)); // directness
+    print(Node->getChild(0), depth + 1); // directness
     Printer << "field offset for ";
     auto entity = Node->getChild(1);
-    print(entity, /*asContext*/ false);
+    print(entity, depth + 1, /*asContext*/ false);
     return nullptr;
   }
   case Node::Kind::EnumCase: {
     Printer << "enum case for ";
     auto entity = Node->getChild(0);
-    print(entity, /*asContext*/ false);
+    print(entity, depth + 1, /*asContext*/ false);
     return nullptr;
   }
   case Node::Kind::ReabstractionThunk:
   case Node::Kind::ReabstractionThunkHelper: {
     if (Options.ShortenThunk) {
       Printer << "thunk for ";
-      print(Node->getChild(Node->getNumChildren() - 1));
+      print(Node->getChild(Node->getNumChildren() - 1), depth + 1);
       return nullptr;
     }
     Printer << "reabstraction thunk ";
@@ -1751,19 +2132,19 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     if (Node->getNumChildren() == 3) {
       auto generics = Node->getChild(0);
       idx = 1;
-      print(generics);
+      print(generics, depth + 1);
       Printer << " ";
     }
     Printer << "from ";
-    print(Node->getChild(idx + 1));
+    print(Node->getChild(idx + 1), depth + 1);
     Printer << " to ";
-    print(Node->getChild(idx));
+    print(Node->getChild(idx), depth + 1);
     return nullptr;
   }
   case Node::Kind::ReabstractionThunkHelperWithGlobalActor: {
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << " with global actor constraint ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     return nullptr;
   }
   case Node::Kind::ReabstractionThunkHelperWithSelf: {
@@ -1772,15 +2153,15 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     if (Node->getNumChildren() == 4) {
       auto generics = Node->getChild(0);
       idx = 1;
-      print(generics);
+      print(generics, depth + 1);
       Printer << " ";
     }
     Printer << "from ";
-    print(Node->getChild(idx + 2));
+    print(Node->getChild(idx + 2), depth + 1);
     Printer << " to ";
-    print(Node->getChild(idx + 1));
+    print(Node->getChild(idx + 1), depth + 1);
     Printer << " self ";
-    print(Node->getChild(idx));
+    print(Node->getChild(idx), depth + 1);
     return nullptr;
   }
   case Node::Kind::AutoDiffFunction:
@@ -1795,7 +2176,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     auto resultIndices = Node->getChild(prefixEndIndex + 2);
     if (kind == Node::Kind::AutoDiffDerivativeVTableThunk)
       Printer << "vtable thunk for ";
-    print(funcKind);
+    print(funcKind, depth + 1);
     Printer << " of ";
     NodePointer optionalGenSig = nullptr;
     for (unsigned i = 0; i < prefixEndIndex; ++i) {
@@ -1806,17 +2187,17 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
         optionalGenSig = Node->getChild(i);
         break;
       }
-      print(Node->getChild(i));
+      print(Node->getChild(i), depth + 1);
     }
     if (Options.ShortenThunk)
       return nullptr;
     Printer << " with respect to parameters ";
-    print(paramIndices);
+    print(paramIndices, depth + 1);
     Printer << " and results ";
-    print(resultIndices);
+    print(resultIndices, depth + 1);
     if (optionalGenSig && Options.DisplayWhereClauses) {
       Printer << " with ";
-      print(optionalGenSig);
+      print(optionalGenSig, depth + 1);
     }
     return nullptr;
   }
@@ -1827,22 +2208,22 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     auto toType = *childIt++;
     if (Options.ShortenThunk) {
       Printer << "for ";
-      print(fromType);
+      print(fromType, depth + 1);
       return nullptr;
     }
     NodePointer optionalGenSig =
         (*childIt)->getKind() == Node::Kind::DependentGenericSignature
             ? *childIt++ : nullptr;
     Printer << "for ";
-    print(*childIt++); // kind
+    print(*childIt++, depth + 1); // kind
     if (optionalGenSig) {
-      print(optionalGenSig);
+      print(optionalGenSig, depth + 1);
       Printer << ' ';
     }
     Printer << " from ";
-    print(fromType);
+    print(fromType, depth + 1);
     Printer << " to ";
-    print(toType);
+    print(toType, depth + 1);
     return nullptr;
   }
   case Node::Kind::AutoDiffSubsetParametersThunk: {
@@ -1852,26 +2233,26 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     auto resultIndices = Node->getChild(currentIndex--);
     auto paramIndices = Node->getChild(currentIndex--);
     auto kind = Node->getChild(currentIndex--);
-    print(kind);
+    print(kind, depth + 1);
     Printer << " from ";
     // Print the "from" thing.
     if (currentIndex == 0) {
-      print(Node->getFirstChild()); // the "from" type
+      print(Node->getFirstChild(), depth + 1); // the "from" type
     } else {
       for (unsigned i = 0; i < currentIndex; ++i) // the "from" global
-        print(Node->getChild(i));
+        print(Node->getChild(i), depth + 1);
     }
     if (Options.ShortenThunk)
       return nullptr;
     Printer << " with respect to parameters ";
-    print(paramIndices);
+    print(paramIndices, depth + 1);
     Printer << " and results ";
-    print(resultIndices);
+    print(resultIndices, depth + 1);
     Printer << " to parameters ";
-    print(toParamIndices);
+    print(toParamIndices, depth + 1);
     if (currentIndex > 0) {
       Printer << " of type ";
-      print(Node->getChild(currentIndex)); // "to" type
+      print(Node->getChild(currentIndex), depth + 1); // "to" type
     }
     return nullptr;
   }
@@ -1920,17 +2301,17 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     for (auto numChildren = Node->getNumChildren();
          idx < numChildren &&
              Node->getChild(idx)->getKind() != Node::Kind::Index; ++idx)
-      print(Node->getChild(idx));
+      print(Node->getChild(idx), depth + 1);
     ++idx; // kind (handled earlier)
     Printer << " with respect to parameters ";
-    print(Node->getChild(idx++)); // parameter indices
+    print(Node->getChild(idx++), depth + 1); // parameter indices
     Printer << " and results ";
-    print(Node->getChild(idx++));
+    print(Node->getChild(idx++), depth + 1);
     if (idx < Node->getNumChildren()) {
       auto *genSig = Node->getChild(idx);
       assert(genSig->getKind() == Node::Kind::DependentGenericSignature);
       Printer << " with ";
-      print(genSig);
+      print(genSig, depth + 1);
     }
     return nullptr;
   }
@@ -1964,6 +2345,21 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     Printer << "opaque type symbolic reference 0x";
     Printer.writeHex(Node->getIndex());
     return nullptr;
+  case Node::Kind::DistributedThunk:
+    if (!Options.ShortenThunk) {
+      Printer << "distributed thunk ";
+    }
+    return nullptr;
+  case Node::Kind::DistributedAccessor:
+    if (!Options.ShortenThunk) {
+      Printer << "distributed accessor for ";
+    }
+    return nullptr;
+  case Node::Kind::AccessibleFunctionRecord:
+    if (!Options.ShortenThunk) {
+      Printer << "accessible function runtime record for ";
+    }
+    return nullptr;
   case Node::Kind::DynamicallyReplaceableFunctionKey:
     if (!Options.ShortenThunk) {
       Printer << "dynamically replaceable key for ";
@@ -1979,165 +2375,189 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
       Printer << "dynamically replaceable variable for ";
     }
     return nullptr;
+  case Node::Kind::BackDeploymentThunk:
+    if (!Options.ShortenThunk) {
+      Printer << "back deployment thunk for ";
+    }
+    return nullptr;
+  case Node::Kind::BackDeploymentFallback:
+    Printer << "back deployment fallback for ";
+    return nullptr;
   case Node::Kind::ProtocolSymbolicReference:
     Printer << "protocol symbolic reference 0x";
     Printer.writeHex(Node->getIndex());
     return nullptr;
   case Node::Kind::GenericTypeMetadataPattern:
     Printer << "generic type metadata pattern for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::Metaclass:
     Printer << "metaclass for ";
-    print(Node->getFirstChild());
+    print(Node->getFirstChild(), depth + 1);
     return nullptr;
   case Node::Kind::ProtocolSelfConformanceDescriptor:
     Printer << "protocol self-conformance descriptor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::ProtocolConformanceDescriptor:
     Printer << "protocol conformance descriptor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::ProtocolConformanceDescriptorRecord:
+    Printer << "protocol conformance descriptor runtime record for ";
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::ProtocolDescriptor:
     Printer << "protocol descriptor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::ProtocolDescriptorRecord:
+    Printer << "protocol descriptor runtime record for ";
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::ProtocolRequirementsBaseDescriptor:
     Printer << "protocol requirements base descriptor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::FullTypeMetadata:
     Printer << "full type metadata for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::TypeMetadata:
     Printer << "type metadata for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::TypeMetadataAccessFunction:
     Printer << "type metadata accessor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::TypeMetadataInstantiationCache:
     Printer << "type metadata instantiation cache for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::TypeMetadataInstantiationFunction:
     Printer << "type metadata instantiation function for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::TypeMetadataSingletonInitializationCache:
     Printer << "type metadata singleton initialization cache for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::TypeMetadataCompletionFunction:
     Printer << "type metadata completion function for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::TypeMetadataDemanglingCache:
     Printer << "demangling cache variable for type metadata for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::TypeMetadataLazyCache:
     Printer << "lazy cache variable for type metadata for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::AssociatedConformanceDescriptor:
     Printer << "associated conformance descriptor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << ".";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     Printer << ": ";
-    print(Node->getChild(2));
+    print(Node->getChild(2), depth + 1);
     return nullptr;
   case Node::Kind::DefaultAssociatedConformanceAccessor:
     Printer << "default associated conformance accessor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << ".";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     Printer << ": ";
-    print(Node->getChild(2));
+    print(Node->getChild(2), depth + 1);
     return nullptr;
   case Node::Kind::AssociatedTypeDescriptor:
     Printer << "associated type descriptor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::AssociatedTypeMetadataAccessor:
     Printer << "associated type metadata accessor for ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     Printer << " in ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::BaseConformanceDescriptor:
     Printer << "base conformance descriptor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << ": ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::DefaultAssociatedTypeMetadataAccessor:
     Printer << "default associated type metadata accessor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::AssociatedTypeWitnessTableAccessor:
     Printer << "associated type witness table accessor for ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     Printer << " : ";
-    print(Node->getChild(2));
+    print(Node->getChild(2), depth + 1);
     Printer << " in ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::BaseWitnessTableAccessor:
     Printer << "base witness table accessor for ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     Printer << " in ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::ClassMetadataBaseOffset:
     Printer << "class metadata base offset for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::PropertyDescriptor:
     Printer << "property descriptor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::NominalTypeDescriptor:
     Printer << "nominal type descriptor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::NominalTypeDescriptorRecord:
+    Printer << "nominal type descriptor runtime record for ";
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OpaqueTypeDescriptor:
     Printer << "opaque type descriptor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::OpaqueTypeDescriptorRecord:
+    Printer << "opaque type descriptor runtime record for ";
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OpaqueTypeDescriptorAccessor:
     Printer << "opaque type descriptor accessor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OpaqueTypeDescriptorAccessorImpl:
     Printer << "opaque type descriptor accessor impl for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OpaqueTypeDescriptorAccessorKey:
     Printer << "opaque type descriptor accessor key for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::OpaqueTypeDescriptorAccessorVar:
     Printer << "opaque type descriptor accessor var for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::CoroutineContinuationPrototype:
     Printer << "coroutine continuation prototype for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::ValueWitness:
     Printer << toString(ValueWitnessKind(Node->getFirstChild()->getIndex()));
     if (Options.ShortenValueWitness) Printer << " for ";
     else Printer << " value witness for ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::ValueWitnessTable:
     Printer << "value witness table for ";
-    print(Node->getFirstChild());
+    print(Node->getFirstChild(), depth + 1);
     return nullptr;
   case Node::Kind::BoundGenericClass:
   case Node::Kind::BoundGenericStructure:
@@ -2145,7 +2565,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::BoundGenericProtocol:
   case Node::Kind::BoundGenericOtherNominalType:
   case Node::Kind::BoundGenericTypeAlias:
-    printBoundGeneric(Node);
+    printBoundGeneric(Node, depth);
     return nullptr;
   case Node::Kind::DynamicSelf:
     Printer << "Self";
@@ -2153,19 +2573,19 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::SILBoxType: {
     Printer << "@box ";
     NodePointer type = Node->getChild(0);
-    print(type);
+    print(type, depth + 1);
     return nullptr;
   }
   case Node::Kind::Metatype: {
     unsigned Idx = 0;
     if (Node->getNumChildren() == 2) {
       NodePointer repr = Node->getChild(Idx);
-      print(repr);
+      print(repr, depth + 1);
       Printer << " ";
       ++Idx;
     }
     NodePointer type = Node->getChild(Idx)->getChild(0);
-    printWithParens(type);
+    printWithParens(type, depth);
     if (isExistentialType(type)) {
       Printer << ".Protocol";
     } else {
@@ -2173,26 +2593,41 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     }
     return nullptr;
   }
+  case Node::Kind::ConstrainedExistential: {
+    Printer << "any ";
+    print(Node->getChild(0), depth + 1);
+    Printer << "<";
+    print(Node->getChild(1), depth + 1);
+    Printer << ">";
+    return nullptr;
+  }
+  case Node::Kind::ConstrainedExistentialRequirementList: {
+    printChildren(Node, depth, ", ");
+    return nullptr;
+  }
   case Node::Kind::ExistentialMetatype: {
     unsigned Idx = 0;
     if (Node->getNumChildren() == 2) {
       NodePointer repr = Node->getChild(Idx);
-      print(repr);
+      print(repr, depth + 1);
       Printer << " ";
       ++Idx;
     }
 
     NodePointer type = Node->getChild(Idx);
-    print(type);
+    print(type, depth + 1);
     Printer << ".Type";
     return nullptr;
   }
+  case Node::Kind::ConstrainedExistentialSelf:
+    Printer << "Self";
+    return nullptr;
   case Node::Kind::MetatypeRepresentation: {
     Printer << Node->getText();
     return nullptr;
   }
   case Node::Kind::AssociatedTypeRef:
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << '.' << Node->getChild(1)->getText();
     return nullptr;
   case Node::Kind::ProtocolList: {
@@ -2202,7 +2637,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     if (type_list->getNumChildren() == 0)
       Printer << "Any";
     else
-      printChildren(type_list, " & ");
+      printChildren(type_list, depth, " & ");
     return nullptr;
   }
   case Node::Kind::ProtocolListWithClass: {
@@ -2210,12 +2645,12 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
       return nullptr;
     NodePointer protocols = Node->getChild(0);
     NodePointer superclass = Node->getChild(1);
-    print(superclass);
+    print(superclass, depth + 1);
     Printer << " & ";
     if (protocols->getNumChildren() < 1)
       return nullptr;
     NodePointer type_list = protocols->getChild(0);
-    printChildren(type_list, " & ");
+    printChildren(type_list, depth, " & ");
     return nullptr;
   }
   case Node::Kind::ProtocolListWithAnyObject: {
@@ -2226,7 +2661,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
       return nullptr;
     NodePointer type_list = protocols->getChild(0);
     if (type_list->getNumChildren() > 0) {
-      printChildren(type_list, " & ");
+      printChildren(type_list, depth, " & ");
       Printer << " & ";
     }
     if (Options.QualifyEntities && Options.DisplayStdlibModule)
@@ -2238,73 +2673,79 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     // Don't print for now.
     return nullptr;
   case Node::Kind::OwningAddressor:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "owningAddressor");
   case Node::Kind::OwningMutableAddressor:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "owningMutableAddressor");
   case Node::Kind::NativeOwningAddressor:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "nativeOwningAddressor");
   case Node::Kind::NativeOwningMutableAddressor:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "nativeOwningMutableAddressor");
   case Node::Kind::NativePinningAddressor:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "nativePinningAddressor");
   case Node::Kind::NativePinningMutableAddressor:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "nativePinningMutableAddressor");
   case Node::Kind::UnsafeAddressor:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "unsafeAddressor");
   case Node::Kind::UnsafeMutableAddressor:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "unsafeMutableAddressor");
   case Node::Kind::GlobalGetter:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "getter");
   case Node::Kind::Getter:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "getter");
   case Node::Kind::Setter:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "setter");
   case Node::Kind::MaterializeForSet:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "materializeForSet");
   case Node::Kind::WillSet:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "willset");
   case Node::Kind::DidSet:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "didset");
   case Node::Kind::ReadAccessor:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "read");
   case Node::Kind::ModifyAccessor:
-    return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
                                 "modify");
+  case Node::Kind::InitAccessor:
+    return printAbstractStorage(Node->getFirstChild(), depth, asPrefixContext,
+                                "init");
   case Node::Kind::Allocator:
-    return printEntity(Node, asPrefixContext, TypePrinting::FunctionStyle,
-                       /*hasName*/false, isClassType(Node->getChild(0)) ?
-                                         "__allocating_init" : "init");
+    return printEntity(
+        Node, depth, asPrefixContext, TypePrinting::FunctionStyle,
+        /*hasName*/ false,
+        isClassType(Node->getChild(0)) ? "__allocating_init" : "init");
   case Node::Kind::Constructor:
-    return printEntity(Node, asPrefixContext, TypePrinting::FunctionStyle,
-                       /*hasName*/Node->getNumChildren() > 2, "init");
+    return printEntity(Node, depth, asPrefixContext,
+                       TypePrinting::FunctionStyle,
+                       /*hasName*/ Node->getNumChildren() > 2, "init");
   case Node::Kind::Destructor:
-    return printEntity(Node, asPrefixContext, TypePrinting::NoType,
-                       /*hasName*/false, "deinit");
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/ false, "deinit");
   case Node::Kind::Deallocator:
-    return printEntity(Node, asPrefixContext, TypePrinting::NoType,
-                       /*hasName*/false, isClassType(Node->getChild(0)) ?
-                                         "__deallocating_deinit" : "deinit");
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/ false,
+                       isClassType(Node->getChild(0)) ? "__deallocating_deinit"
+                                                      : "deinit");
   case Node::Kind::IVarInitializer:
-    return printEntity(Node, asPrefixContext, TypePrinting::NoType,
-                       /*hasName*/false, "__ivar_initializer");
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/ false, "__ivar_initializer");
   case Node::Kind::IVarDestroyer:
-    return printEntity(Node, asPrefixContext, TypePrinting::NoType,
-                       /*hasName*/false, "__ivar_destroyer");
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/ false, "__ivar_destroyer");
   case Node::Kind::ProtocolConformance: {
     NodePointer child0 = Node->getChild(0);
     NodePointer child1 = Node->getChild(1);
@@ -2312,24 +2753,24 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     if (Node->getNumChildren() == 4) {
       // TODO: check if this is correct
       Printer << "property behavior storage of ";
-      print(child2);
+      print(child2, depth + 1);
       Printer << " in ";
-      print(child0);
+      print(child0, depth + 1);
       Printer << " : ";
-      print(child1);
+      print(child1, depth + 1);
     } else {
-      print(child0);
+      print(child0, depth + 1);
       if (Options.DisplayProtocolConformances) {
         Printer << " : ";
-        print(child1);
+        print(child1, depth + 1);
         Printer << " in ";
-        print(child2);
+        print(child2, depth + 1);
       }
     }
     return nullptr;
   }
   case Node::Kind::TypeList:
-    printChildren(Node);
+    printChildren(Node, depth);
     return nullptr;
   case Node::Kind::LabelList:
     return nullptr;
@@ -2354,6 +2795,12 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::ImplEscaping:
     Printer << "@escaping";
     return nullptr;
+  case Node::Kind::ImplErasedIsolation:
+    Printer << "@isolated(any)";
+    return nullptr;
+  case Node::Kind::ImplSendingResult:
+    Printer << "sending";
+    return nullptr;
   case Node::Kind::ImplConvention:
     Printer << Node->getText();
     return nullptr;
@@ -2364,6 +2811,13 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     // Otherwise, print with trailing space.
     Printer << Node->getText() << ' ';
     return nullptr;
+  case Node::Kind::ImplParameterSending:
+    // Skip if text is empty.
+    if (Node->getText().empty())
+      return nullptr;
+    // Otherwise, print with trailing space.
+    Printer << Node->getText() << ' ';
+    return nullptr;
   case Node::Kind::ImplFunctionAttribute:
     Printer << Node->getText();
     return nullptr;
@@ -2375,7 +2829,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
       break;
     case 2:
       Printer << Node->getChild(0)->getText() << ", mangledCType: \"";
-      print(Node->getChild(1));
+      print(Node->getChild(1), depth + 1);
       Printer << '"';
       break;
     default:
@@ -2388,37 +2842,42 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     return nullptr;
   case Node::Kind::ImplErrorResult:
     Printer << "@error ";
-    printChildren(Node, " ");
+    printChildren(Node, depth, " ");
     return nullptr;
   case Node::Kind::ImplYield:
     Printer << "@yields ";
-    printChildren(Node, " ");
+    printChildren(Node, depth, " ");
     return nullptr;
   case Node::Kind::ImplParameter:
   case Node::Kind::ImplResult:
     // Children: `convention, differentiability?, type`
     // Print convention.
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << " ";
     // Print differentiability, if it exists.
     if (Node->getNumChildren() == 3)
-      print(Node->getChild(1));
+      print(Node->getChild(1), depth + 1);
+    // Print differentiability and sending if it exists.
+    if (Node->getNumChildren() == 4) {
+      print(Node->getChild(1), depth + 1);
+      print(Node->getChild(2), depth + 1);
+    }
     // Print type.
-    print(Node->getLastChild());
+    print(Node->getLastChild(), depth + 1);
     return nullptr;
   case Node::Kind::ImplFunctionType:
-    printImplFunctionType(Node);
+    printImplFunctionType(Node, depth);
     return nullptr;
   case Node::Kind::ImplInvocationSubstitutions:
     Printer << "for <";
-    printChildren(Node->getChild(0), ", ");
+    printChildren(Node->getChild(0), depth, ", ");
     Printer << '>';
     return nullptr;
   case Node::Kind::ImplPatternSubstitutions:
     Printer << "@substituted ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << " for <";
-    printChildren(Node->getChild(1), ", ");
+    printChildren(Node->getChild(1), depth, ", ");
     Printer << '>';
     return nullptr;
   case Node::Kind::ErrorType:
@@ -2427,63 +2886,39 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
       
   case Node::Kind::DependentPseudogenericSignature:
   case Node::Kind::DependentGenericSignature: {
-    Printer << '<';
-    
-    unsigned depth = 0;
-    unsigned numChildren = Node->getNumChildren();
-    for (;
-         depth < numChildren
-           && Node->getChild(depth)->getKind()
-               == Node::Kind::DependentGenericParamCount;
-         ++depth) {
-      if (depth != 0)
-        Printer << "><";
-      
-      unsigned count = Node->getChild(depth)->getIndex();
-      for (unsigned index = 0; index < count; ++index) {
-        if (index != 0)
-          Printer << ", ";
-        // Limit the number of printed generic parameters. In practice this
-        // it will never be exceeded. The limit is only imporant for malformed
-        // symbols where count can be really huge.
-        if (index >= 128) {
-          Printer << "...";
-          break;
-        }
-        // FIXME: Depth won't match when a generic signature applies to a
-        // method in generic type context.
-        Printer << Options.GenericParameterName(depth, index);
-      }
-    }
-    
-    if (depth != numChildren) {
-      if (Options.DisplayWhereClauses) {
-        Printer << " where ";
-        for (unsigned i = depth; i < numChildren; ++i) {
-          if (i > depth)
-            Printer << ", ";
-          print(Node->getChild(i));
-        }
-      }
-    }
-    Printer << '>';
+    printGenericSignature(Node, depth);
     return nullptr;
   }
   case Node::Kind::DependentGenericParamCount:
+  case Node::Kind::DependentGenericParamPackMarker:
     printer_unreachable("should be printed as a child of a "
                         "DependentGenericSignature");
   case Node::Kind::DependentGenericConformanceRequirement: {
     NodePointer type = Node->getChild(0);
     NodePointer reqt = Node->getChild(1);
-    print(type);
+    print(type, depth + 1);
     Printer << ": ";
-    print(reqt);
+    print(reqt, depth + 1);
+    return nullptr;
+  }
+  case Node::Kind::DependentGenericInverseConformanceRequirement: {
+    NodePointer type = Node->getChild(0);
+    print(type, depth + 1);
+    Printer << ": ~";
+    switch (Node->getChild(1)->getIndex()) {
+#define INVERTIBLE_PROTOCOL(Name, Bit) \
+    case Bit: Printer << "Swift." << #Name; break;
+#include "swift/ABI/InvertibleProtocols.def"
+    default:
+      Printer << "Swift.<bit " << Node->getChild(1)->getIndex() << ">";
+      break;
+    }
     return nullptr;
   }
   case Node::Kind::DependentGenericLayoutRequirement: {
     NodePointer type = Node->getChild(0);
     NodePointer layout = Node->getChild(1);
-    print(type);
+    print(type, depth + 1);
     Printer << ": ";
     assert(layout->getKind() == Node::Kind::Identifier);
     assert(layout->getText().size() == 1);
@@ -2509,10 +2944,10 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     Printer << name;
     if (Node->getNumChildren() > 2) {
       Printer << "(";
-      print(Node->getChild(2));
+      print(Node->getChild(2), depth + 1);
       if (Node->getNumChildren() > 3) {
         Printer << ", ";
-        print(Node->getChild(3));
+        print(Node->getChild(3), depth + 1);
       }
       Printer << ")";
     }
@@ -2521,10 +2956,20 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::DependentGenericSameTypeRequirement: {
     NodePointer fst = Node->getChild(0);
     NodePointer snd = Node->getChild(1);
-    
-    print(fst);
+
+    print(fst, depth + 1);
     Printer << " == ";
-    print(snd);
+    print(snd, depth + 1);
+    return nullptr;
+  }
+  case Node::Kind::DependentGenericSameShapeRequirement: {
+    NodePointer fst = Node->getChild(0);
+    NodePointer snd = Node->getChild(1);
+
+    print(fst, depth + 1);
+    Printer << ".shape == ";
+    print(snd, depth + 1);
+    Printer << ".shape";
     return nullptr;
   }
   case Node::Kind::DependentGenericParamType: {
@@ -2536,43 +2981,43 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::DependentGenericType: {
     NodePointer sig = Node->getChild(0);
     NodePointer depTy = Node->getChild(1);
-    print(sig);
+    print(sig, depth + 1);
     if (needSpaceBeforeType(depTy))
       Printer << ' ';
-    print(depTy);
+    print(depTy, depth + 1);
     return nullptr;
   }
   case Node::Kind::DependentMemberType: {
     NodePointer base = Node->getChild(0);
-    print(base);
+    print(base, depth + 1);
     Printer << '.';
     NodePointer assocTy = Node->getChild(1);
-    print(assocTy);
+    print(assocTy, depth + 1);
     return nullptr;
   }
   case Node::Kind::DependentAssociatedTypeRef: {
     if (Node->getNumChildren() > 1) {
-      print(Node->getChild(1));
+      print(Node->getChild(1), depth + 1);
       Printer << '.';
     }
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   }
   case Node::Kind::ReflectionMetadataBuiltinDescriptor:
     Printer << "reflection metadata builtin descriptor ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::ReflectionMetadataFieldDescriptor:
     Printer << "reflection metadata field descriptor ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::ReflectionMetadataAssocTypeDescriptor:
     Printer << "reflection metadata associated type descriptor ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::ReflectionMetadataSuperclassDescriptor:
     Printer << "reflection metadata superclass descriptor ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
 
   case Node::Kind::ConcurrentFunctionType:
@@ -2602,16 +3047,28 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::GlobalActorFunctionType: {
     if (Node->getNumChildren() > 0) {
       Printer << '@';
-      print(Node->getChild(0));
+      print(Node->getChild(0), depth + 1);
       Printer << ' ';
     }
     return nullptr;
   }
+  case Node::Kind::IsolatedAnyFunctionType:
+    Printer << "@isolated(any) ";
+    return nullptr;
+  case Node::Kind::SendingResultFunctionType:
+    Printer << "sending ";
+    return nullptr;
   case Node::Kind::AsyncAnnotation:
-    Printer << " async ";
+    Printer << " async";
     return nullptr;
   case Node::Kind::ThrowsAnnotation:
-    Printer << " throws ";
+    Printer << " throws";
+    return nullptr;
+  case Node::Kind::TypedThrowsAnnotation:
+    Printer << " throws(";
+    if (Node->getNumChildren() == 1)
+      print(Node->getChild(0), depth + 1);
+    Printer << ")";
     return nullptr;
   case Node::Kind::EmptyList:
     Printer << " empty-list ";
@@ -2632,17 +3089,17 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
       assert(signature->getKind() == Node::Kind::DependentGenericSignature);
       genericArgs = Node->getChild(2);
       assert(genericArgs->getKind() == Node::Kind::TypeList);
-      
-      print(signature);
+
+      print(signature, depth + 1);
       Printer << ' ';
     }
-    print(layout);
+    print(layout, depth + 1);
     if (genericArgs) {
       Printer << " <";
       for (unsigned i = 0, e = genericArgs->getNumChildren(); i < e; ++i) {
         if (i > 0)
           Printer << ", ";
-        print(genericArgs->getChild(i));
+        print(genericArgs->getChild(i), depth + 1);
       }
       Printer << '>';
     }
@@ -2654,7 +3111,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
       if (i > 0)
         Printer << ',';
       Printer << ' ';
-      print(Node->getChild(i));
+      print(Node->getChild(i), depth + 1);
     }
     Printer << " }";
     return nullptr;
@@ -2665,89 +3122,111 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
       : "var ");
     assert(Node->getNumChildren() == 1
            && Node->getChild(0)->getKind() == Node::Kind::Type);
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::AssocTypePath:
-    printChildren(Node->begin(), Node->end(), ".");
-      return nullptr;
+    printChildren(Node->begin(), Node->end(), depth, ".");
+    return nullptr;
   case Node::Kind::ModuleDescriptor:
     Printer << "module descriptor ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::AnonymousDescriptor:
     Printer << "anonymous descriptor ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::ExtensionDescriptor:
     Printer << "extension descriptor ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::AssociatedTypeGenericParamRef:
     Printer << "generic parameter reference for associated type ";
-    printChildren(Node);
+    printChildren(Node, depth);
     return nullptr;
   case Node::Kind::AnyProtocolConformanceList:
-    printChildren(Node);
+    if (Node->getNumChildren() > 0) {
+      Printer << "(";
+      for (unsigned i = 0; i < Node->getNumChildren(); ++i) {
+        if (i > 0)
+          Printer << ", ";
+        print(Node->getChild(i), depth + 1);
+      }
+      Printer << ")";
+    }
     return nullptr;
   case Node::Kind::ConcreteProtocolConformance:
     Printer << "concrete protocol conformance ";
     if (Node->hasIndex())
       Printer << "#" << Node->getIndex() << " ";
-    printChildren(Node);
+    print(Node->getChild(0), depth + 1);
+    Printer << " to ";
+    print(Node->getChild(1), depth + 1);
+    if (Node->getNumChildren() > 2 &&
+        Node->getChild(2)->getNumChildren() > 0) {
+      Printer << " with conditional requirements: ";
+      print(Node->getChild(2), depth + 1);
+    }
+    return nullptr;
+  case Node::Kind::PackProtocolConformance:
+    Printer << "pack protocol conformance ";
+    printChildren(Node, depth);
     return nullptr;
   case Node::Kind::DependentAssociatedConformance:
     Printer << "dependent associated conformance ";
-    printChildren(Node);
+    printChildren(Node, depth);
     return nullptr;
   case Node::Kind::DependentProtocolConformanceAssociated:
     Printer << "dependent associated protocol conformance ";
     printOptionalIndex(Node->getChild(2));
-    print(Node->getChild(0));
-    print(Node->getChild(1));
+    print(Node->getChild(0), depth + 1);
+    Printer << " to ";
+    print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::DependentProtocolConformanceInherited:
     Printer << "dependent inherited protocol conformance ";
     printOptionalIndex(Node->getChild(2));
-    print(Node->getChild(0));
-    print(Node->getChild(1));
+    print(Node->getChild(0), depth + 1);
+    Printer << " to ";
+    print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::DependentProtocolConformanceRoot:
     Printer << "dependent root protocol conformance ";
     printOptionalIndex(Node->getChild(2));
-    print(Node->getChild(0));
-    print(Node->getChild(1));
+    print(Node->getChild(0), depth + 1);
+    Printer << " to ";
+    print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::ProtocolConformanceRefInTypeModule:
     Printer << "protocol conformance ref (type's module) ";
-    printChildren(Node);
+    printChildren(Node, depth);
     return nullptr;
   case Node::Kind::ProtocolConformanceRefInProtocolModule:
     Printer << "protocol conformance ref (protocol's module) ";
-    printChildren(Node);
+    printChildren(Node, depth);
     return nullptr;
   case Node::Kind::ProtocolConformanceRefInOtherModule:
     Printer << "protocol conformance ref (retroactive) ";
-    printChildren(Node);
+    printChildren(Node, depth);
     return nullptr;
   case Node::Kind::SugaredOptional:
-    printWithParens(Node->getChild(0));
+    printWithParens(Node->getChild(0), depth);
     Printer << "?";
     return nullptr;
   case Node::Kind::SugaredArray:
     Printer << "[";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << "]";
     return nullptr;
   case Node::Kind::SugaredDictionary:
     Printer << "[";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << " : ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     Printer << "]";
     return nullptr;
   case Node::Kind::SugaredParen:
     Printer << "(";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << ")";
     return nullptr;
   case Node::Kind::OpaqueReturnType:
@@ -2755,36 +3234,36 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     return nullptr;
   case Node::Kind::OpaqueReturnTypeOf:
     Printer << "<<opaque return type of ";
-    printChildren(Node);
+    printChildren(Node, depth);
     Printer << ">>";
     return nullptr;
   case Node::Kind::OpaqueType:
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     Printer << '.';
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::AccessorFunctionReference:
     Printer << "accessor function at " << Node->getIndex();
     return nullptr;
   case Node::Kind::CanonicalSpecializedGenericMetaclass:
     Printer << "specialized generic metaclass for ";
-    print(Node->getFirstChild());
+    print(Node->getFirstChild(), depth + 1);
     return nullptr;
   case Node::Kind::CanonicalSpecializedGenericTypeMetadataAccessFunction:
     Printer << "canonical specialized generic type metadata accessor for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::MetadataInstantiationCache:
     Printer << "metadata instantiation cache for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::NoncanonicalSpecializedGenericTypeMetadata:
     Printer << "noncanonical specialized generic type metadata for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::NoncanonicalSpecializedGenericTypeMetadataCache:
     Printer << "cache variable for noncanonical specialized generic type metadata for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::GlobalVariableOnceToken:
   case Node::Kind::GlobalVariableOnceFunction:
@@ -2792,18 +3271,18 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
                   ? "one-time initialization token for "
                   : "one-time initialization function for ");
     printContext(Node->getChild(0));
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     return nullptr;
   case Node::Kind::GlobalVariableOnceDeclList:
     if (Node->getNumChildren() == 1) {
-      print(Node->getChild(0));
+      print(Node->getChild(0), depth + 1);
     } else {
       Printer << '(';
       for (unsigned i = 0, e = Node->getNumChildren(); i < e; ++i) {
         if (i != 0) {
           Printer << ", ";
         }
-        print(Node->getChild(i));
+        print(Node->getChild(i), depth + 1);
       }
       Printer << ')';
     }
@@ -2814,10 +3293,10 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::ObjCAsyncCompletionHandlerImpl:
     Printer << "@objc completion handler block implementation for ";
     if (Node->getNumChildren() >= 4)
-      print(Node->getChild(3));
-    print(Node->getChild(0));
+      print(Node->getChild(3), depth + 1);
+    print(Node->getChild(0), depth + 1);
     Printer << " with result type ";
-    print(Node->getChild(1));
+    print(Node->getChild(1), depth + 1);
     switch (Node->getChild(2)->getIndex()) {
     case 0:
       break;
@@ -2835,7 +3314,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::CanonicalPrespecializedGenericTypeCachingOnceToken:
     Printer << "flag for loading of canonical specialized generic type "
                "metadata for ";
-    print(Node->getChild(0));
+    print(Node->getChild(0), depth + 1);
     return nullptr;
   case Node::Kind::AsyncFunctionPointer:
     Printer << "async function pointer to ";
@@ -2843,7 +3322,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::AsyncAwaitResumePartialFunction:
     if (Options.ShowAsyncResumePartial) {
       Printer << "(";
-      print(Node->getChild(0));
+      print(Node->getChild(0), depth + 1);
       Printer << ")";
       Printer << " await resume partial function for ";
     }
@@ -2851,36 +3330,102 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::AsyncSuspendResumePartialFunction:
     if (Options.ShowAsyncResumePartial) {
       Printer << "(";
-      print(Node->getChild(0));
+      print(Node->getChild(0), depth + 1);
       Printer << ")";
       Printer << " suspend resume partial function for ";
     }
     return nullptr;
+  case Node::Kind::Uniquable:
+    Printer << "uniquable ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::ExtendedExistentialTypeShape: {
+    // Printing the requirement signature is pretty useless if we
+    // don't print `where` clauses.
+    auto savedDisplayWhereClauses = Options.DisplayWhereClauses;
+    Options.DisplayWhereClauses = true;
+
+    NodePointer genSig = nullptr, type = nullptr;
+    if (Node->getNumChildren() == 2) {
+      genSig = Node->getChild(1);
+      type = Node->getChild(2);
+    } else {
+      type = Node->getChild(1);
+    }
+
+    Printer << "existential shape for ";
+    if (genSig) {
+      print(genSig, depth + 1);
+      Printer << " ";
+    }
+    Printer << "any ";
+    print(type, depth + 1);
+
+    Options.DisplayWhereClauses = savedDisplayWhereClauses;
+    return nullptr;
+  }
+  case Node::Kind::UniqueExtendedExistentialTypeShapeSymbolicReference:
+    Printer << "unique existential shape symbolic reference 0x";
+    Printer.writeHex(Node->getIndex());
+    return nullptr;
+  case Node::Kind::NonUniqueExtendedExistentialTypeShapeSymbolicReference:
+    Printer << "non-unique existential shape symbolic reference 0x";
+    Printer.writeHex(Node->getIndex());
+    return nullptr;
+  case Node::Kind::ObjectiveCProtocolSymbolicReference:
+    Printer << "objective-c protocol symbolic reference 0x";
+    Printer.writeHex(Node->getIndex());
+    return nullptr;
+  case Node::Kind::SymbolicExtendedExistentialType: {
+    auto shape = Node->getChild(0);
+    bool isUnique =
+      (shape->getKind() ==
+         Node::Kind::UniqueExtendedExistentialTypeShapeSymbolicReference);
+    Printer << "symbolic existential type ("
+            << (isUnique ? "" : "non-")
+            << "unique) 0x";
+    Printer.writeHex(shape->getIndex());
+    Printer << " <";
+    print(Node->getChild(1), depth + 1);
+    if (Node->getNumChildren() > 2) {
+      Printer << ", ";
+      print(Node->getChild(2), depth + 1);
+    }
+    Printer << ">";
+
+    return nullptr;
+  }
+  case Node::Kind::HasSymbolQuery:
+    Printer << "#_hasSymbol query for ";
+    return nullptr;
+  case Node::Kind::OpaqueReturnTypeIndex:
+  case Node::Kind::OpaqueReturnTypeParent:
+    return nullptr;
   }
 
   printer_unreachable("bad node kind!");
 }
 
-NodePointer NodePrinter::printAbstractStorage(NodePointer Node,
+NodePointer NodePrinter::printAbstractStorage(NodePointer Node, unsigned depth,
                                               bool asPrefixContent,
                                               StringRef ExtraName) {
   switch (Node->getKind()) {
     case Node::Kind::Variable:
-      return printEntity(Node, asPrefixContent, TypePrinting::WithColon,
-                         /*hasName*/true, ExtraName);
+      return printEntity(Node, depth, asPrefixContent, TypePrinting::WithColon,
+                         /*hasName*/ true, ExtraName);
     case Node::Kind::Subscript:
-      return printEntity(Node, asPrefixContent, TypePrinting::WithColon,
-                         /*hasName*/false, ExtraName, /*ExtraIndex*/-1,
+      return printEntity(Node, depth, asPrefixContent, TypePrinting::WithColon,
+                         /*hasName*/ false, ExtraName, /*ExtraIndex*/ -1,
                          "subscript");
     default:
       printer_unreachable("Not an abstract storage node");
   }
 }
 
-NodePointer NodePrinter::
-printEntity(NodePointer Entity, bool asPrefixContext, TypePrinting TypePr,
-            bool hasName, StringRef ExtraName, int ExtraIndex,
-            StringRef OverwriteName) {
+NodePointer NodePrinter::printEntity(NodePointer Entity, unsigned depth,
+                                     bool asPrefixContext, TypePrinting TypePr,
+                                     bool hasName, StringRef ExtraName,
+                                     int ExtraIndex, StringRef OverwriteName) {
 
   NodePointer genericFunctionTypeList = nullptr;
   if (Entity->getKind() == Node::Kind::BoundGenericFunction) {
@@ -2912,7 +3457,7 @@ printEntity(NodePointer Entity, bool asPrefixContext, TypePrinting TypePr,
       PostfixContext = Context;
     } else {
       size_t CurrentPos = Printer.getStringRef().size();
-      PostfixContext = print(Context, /*asPrefixContext*/true);
+      PostfixContext = print(Context, depth + 1, /*asPrefixContext*/ true);
 
       // Was the context printed as prefix?
       if (Printer.getStringRef().size() != CurrentPos)
@@ -2921,11 +3466,14 @@ printEntity(NodePointer Entity, bool asPrefixContext, TypePrinting TypePr,
   }
 
   if (hasName || !OverwriteName.empty()) {
-    assert(ExtraIndex < 0 && "Can't have a name and extra index");
     if (!ExtraName.empty() && MultiWordName) {
       Printer << ExtraName;
+      if (ExtraIndex >= 0)
+        Printer << ExtraIndex;
+
       Printer << " of ";
       ExtraName = "";
+      ExtraIndex = -1;
     }
     size_t CurrentPos = Printer.getStringRef().size();
     if (!OverwriteName.empty()) {
@@ -2933,10 +3481,10 @@ printEntity(NodePointer Entity, bool asPrefixContext, TypePrinting TypePr,
     } else {
       auto Name = Entity->getChild(1);
       if (Name->getKind() != Node::Kind::PrivateDeclName)
-        print(Name);
+        print(Name, depth + 1);
 
       if (auto PrivateName = getChildIf(Entity, Node::Kind::PrivateDeclName))
-        print(PrivateName);
+        print(PrivateName, depth + 1);
     }
     if (Printer.getStringRef().size() != CurrentPos && !ExtraName.empty())
       Printer << '.';
@@ -2971,13 +3519,13 @@ printEntity(NodePointer Entity, bool asPrefixContext, TypePrinting TypePr,
     if (TypePr == TypePrinting::WithColon) {
       if (Options.DisplayEntityTypes) {
         Printer << " : ";
-        printEntityType(Entity, type, genericFunctionTypeList);
+        printEntityType(Entity, type, genericFunctionTypeList, depth);
       }
-    } else {
+    } else if (shouldShowEntityType(Entity->getKind(), Options)) {
       assert(TypePr == TypePrinting::FunctionStyle);
       if (MultiWordName || needSpaceBeforeType(type))
         Printer << ' ';
-      printEntityType(Entity, type, genericFunctionTypeList);
+      printEntityType(Entity, type, genericFunctionTypeList, depth);
     }
   }
   if (!asPrefixContext && PostfixContext &&
@@ -2991,34 +3539,188 @@ printEntity(NodePointer Entity, bool asPrefixContext, TypePrinting TypePr,
     } else {
       Printer << " in ";
     }
-    print(PostfixContext);
+    print(PostfixContext, depth + 1);
     PostfixContext = nullptr;
   }
   return PostfixContext;
-};
+}
 
 void NodePrinter::printEntityType(NodePointer Entity, NodePointer type,
-                                  NodePointer genericFunctionTypeList) {
+                                  NodePointer genericFunctionTypeList,
+                                  unsigned depth) {
   NodePointer labelList = getChildIf(Entity, Node::Kind::LabelList);
   if (labelList || genericFunctionTypeList) {
     if (genericFunctionTypeList) {
       Printer << "<";
-      printChildren(genericFunctionTypeList, ", ");
+      printChildren(genericFunctionTypeList, depth, ", ");
       Printer << ">";
     }
     if (type->getKind() == Node::Kind::DependentGenericType) {
       if (!genericFunctionTypeList)
-        print(type->getChild(0)); // generic signature
+        print(type->getChild(0), depth + 1); // generic signature
 
       auto dependentType = type->getChild(1);
       if (needSpaceBeforeType(dependentType))
         Printer << ' ';
       type = dependentType->getFirstChild();
     }
-    printFunctionType(labelList, type);
+    printFunctionType(labelList, type, depth);
+  } else {
+    print(type, depth + 1);
+  }
+}
+
+NodePointer
+matchSequenceOfKinds(NodePointer start,
+                     std::vector<std::tuple<Node::Kind, size_t>> pattern) {
+  if (start != nullptr) {
+    NodePointer current = start;
+    size_t idx = 0;
+    while (idx < pattern.size()) {
+      std::tuple<Node::Kind, size_t> next = pattern[idx];
+      idx += 1;
+      NodePointer nextChild = current->getChild(std::get<1>(next));
+      if (nextChild != nullptr && nextChild->getKind() == std::get<0>(next)) {
+        current = nextChild;
+      } else {
+        return nullptr;
+      }
+    }
+    if (idx == pattern.size()) {
+      return current;
+    } else {
+      return nullptr;
+    }
   } else {
-    print(type);
+    return nullptr;
+  }
+}
+
+std::string Demangle::keyPathSourceString(const char *MangledName,
+                                          size_t MangledNameLength) {
+  std::string invalid = "";
+  std::string unlabelledArg = "_: ";
+  Context ctx;
+  NodePointer root =
+      ctx.demangleSymbolAsNode(StringRef(MangledName, MangledNameLength));
+  if (!root)
+    return invalid;
+  if (root->getNumChildren() >= 1) {
+    NodePointer firstChild = root->getChild(0);
+    if (firstChild->getKind() == Node::Kind::KeyPathGetterThunkHelper) {
+      NodePointer child = firstChild->getChild(0);
+      switch (child->getKind()) {
+      case Node::Kind::Subscript: {
+        std::string subscriptText = "subscript(";
+        std::vector<std::string> argumentTypeNames;
+        auto getArgumentTypeName = [&argumentTypeNames](size_t i) {
+          if (i < argumentTypeNames.size())
+            return argumentTypeNames[i];
+          return std::string("<unknown>");
+        };
+        auto getArgumentNodeName = [](NodePointer node) {
+          if (node->getKind() == Node::Kind::Identifier) {
+            return std::string(node->getText());
+          }
+          if (node->getKind() == Node::Kind::LocalDeclName) {
+            auto text = node->getChild(1)->getText();
+            auto index = node->getChild(0)->getIndex() + 1;
+            return std::string(text) + " #" + std::to_string(index);
+          }
+          return std::string("<unknown>");
+        };
+        // Multiple arguments case
+        NodePointer argList = matchSequenceOfKinds(
+            child, {
+                       std::make_pair(Node::Kind::Type, 2),
+                       std::make_pair(Node::Kind::FunctionType, 0),
+                       std::make_pair(Node::Kind::ArgumentTuple, 0),
+                       std::make_pair(Node::Kind::Type, 0),
+                       std::make_pair(Node::Kind::Tuple, 0),
+                   });
+        if (argList != nullptr) {
+          size_t numArgumentTypes = argList->getNumChildren();
+          size_t idx = 0;
+          while (idx < numArgumentTypes) {
+            NodePointer argumentType = argList->getChild(idx);
+            idx += 1;
+            if (argumentType->getKind() == Node::Kind::TupleElement) {
+              argumentType =
+                  argumentType->getChild(0)->getChild(0)->getChild(1);
+              argumentTypeNames.push_back(getArgumentNodeName(argumentType));
+              continue;
+            }
+            argumentTypeNames.push_back("<Unknown>");
+          }
+        } else {
+          // Case where there is a single argument
+          argList = matchSequenceOfKinds(
+              child, {
+                         std::make_pair(Node::Kind::Type, 2),
+                         std::make_pair(Node::Kind::FunctionType, 0),
+                         std::make_pair(Node::Kind::ArgumentTuple, 0),
+                         std::make_pair(Node::Kind::Type, 0),
+                     });
+          if (argList != nullptr) {
+            argumentTypeNames.push_back(
+                getArgumentNodeName(argList->getChild(0)->getChild(1)));
+          }
+        }
+        child = child->getChild(1);
+        size_t idx = 0;
+        // There is an argument label:
+        if (child != nullptr) {
+          if (child->getKind() == Node::Kind::LabelList) {
+            size_t numChildren = child->getNumChildren();
+            if (numChildren == 0) {
+              subscriptText += unlabelledArg + getArgumentTypeName(0);
+            } else {
+              while (idx < numChildren) {
+                Node *argChild = child->getChild(idx);
+                idx += 1;
+                if (argChild->getKind() == Node::Kind::Identifier) {
+                  subscriptText += std::string(argChild->getText()) + ": " +
+                                   getArgumentTypeName(idx - 1);
+                  if (idx != numChildren) {
+                    subscriptText += ", ";
+                  }
+                } else if (argChild->getKind() ==
+                               Node::Kind::FirstElementMarker ||
+                           argChild->getKind() == Node::Kind::VariadicMarker) {
+                  subscriptText += unlabelledArg + getArgumentTypeName(idx - 1);
+                }
+              }
+            }
+          }
+        } else {
+          subscriptText += unlabelledArg + getArgumentTypeName(0);
+        }
+        return subscriptText + ")";
+      }
+      case Node::Kind::Variable: {
+        child = child->getChild(1);
+        if (child == nullptr) {
+          return invalid;
+        }
+        if (child->getKind() == Node::Kind::PrivateDeclName) {
+          child = child->getChild(1);
+          if (child == nullptr) {
+            return invalid;
+          }
+          if (child->getKind() == Node::Kind::Identifier) {
+            return std::string(child->getText());
+          }
+        } else if (child->getKind() == Node::Kind::Identifier) {
+          return std::string(child->getText());
+        }
+        break;
+      }
+      default:
+        return invalid;
+      }
+    }
   }
+  return invalid;
 }
 
 std::string Demangle::nodeToString(NodePointer root,
@@ -3028,3 +3730,5 @@ std::string Demangle::nodeToString(NodePointer root,
 
   return NodePrinter(options).printRoot(root);
 }
+
+#endif
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/OldDemangler.cpp b/symbolic-demangle/vendor/swift/lib/Demangling/OldDemangler.cpp
deleted file mode 100644
index 95fa2af28..000000000
--- a/symbolic-demangle/vendor/swift/lib/Demangling/OldDemangler.cpp
+++ /dev/null
@@ -1,2350 +0,0 @@
-//===--- OldDemangler.cpp - Old Swift Demangling --------------------------===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file implements Swift symbol demangling with the old scheme.
-//
-//===----------------------------------------------------------------------===//
-
-#include "swift/Demangling/Demangle.h"
-#include "swift/Demangling/Demangler.h"
-#include "swift/Demangling/ManglingMacros.h"
-#include "swift/Demangling/ManglingUtils.h"
-#include "swift/Strings.h"
-#include "swift/Demangling/Punycode.h"
-#include "llvm/ADT/Optional.h"
-#include <functional>
-#include <vector>
-#include <cstdio>
-#include <cstdlib>
-
-using namespace swift;
-using namespace Demangle;
-
-namespace {
-  struct FindPtr {
-    FindPtr(Node *v) : Target(v) {}
-    bool operator()(NodePointer sp) const {
-      return sp == Target;
-    }
-  private:
-    Node *Target;
-  };
-} // end anonymous namespace
-
-static bool isStartOfIdentifier(char c) {
-  if (c >= '0' && c <= '9')
-    return true;
-  return c == 'o';
-}
-
-static bool isStartOfNominalType(char c) {
-  switch (c) {
-  case 'C':
-  case 'V':
-  case 'O':
-    return true;
-  default:
-    return false;
-  }
-}
-
-static bool isStartOfEntity(char c) {
-  switch (c) {
-  case 'F':
-  case 'I':
-  case 'v':
-  case 'P':
-  case 's':
-  case 'Z':
-    return true;
-  default:
-    return isStartOfNominalType(c);
-  }
-}
-
-static Node::Kind nominalTypeMarkerToNodeKind(char c) {
-  if (c == 'C')
-    return Node::Kind::Class;
-  if (c == 'V')
-    return Node::Kind::Structure;
-  if (c == 'O')
-    return Node::Kind::Enum;
-  return Node::Kind::Identifier;
-}
-
-namespace {
-
-/// A convenient class for parsing characters out of a string.
-class NameSource {
-  StringRef Text;
-public:
-  NameSource(StringRef text) : Text(text) {}
-
-  /// Return whether there are at least len characters remaining.
-  bool hasAtLeast(size_t len) { return (len <= Text.size()); }
-
-  bool isEmpty() { return Text.empty(); }
-  explicit operator bool() { return !isEmpty(); }
-
-  /// Return the next character without claiming it.  Asserts that
-  /// there is at least one remaining character.
-  char peek() {
-    if (isEmpty()) {
-      // Return an otherwise unused character to prevent crashes for malformed
-      // symbols.
-      return '.';
-    }
-    return Text.front();
-  }
-
-  /// Claim and return the next character.  Asserts that there is at
-  /// least one remaining character.
-  char next() {
-    char c = peek();
-    if (!isEmpty())
-      advanceOffset(1);
-    return c;
-  }
-
-  /// Claim the next character if it exists and equals the given
-  /// character.
-  bool nextIf(char c) {
-    if (isEmpty() || peek() != c) return false;
-    advanceOffset(1);
-    return true;
-  }
-
-  /// Claim the next few characters if they exactly match the given string.
-  bool nextIf(StringRef str) {
-    if (!Text.startswith(str)) return false;
-    advanceOffset(str.size());
-    return true;
-  }
-
-  /// Return the next len characters without claiming them.  Asserts
-  /// that there are at least so many characters.
-  StringRef slice(size_t len) { return Text.substr(0, len); }
-
-  /// Return the current string ref without claiming any characters.
-  StringRef str() { return Text; }
-
-  /// Claim the next len characters.
-  void advanceOffset(size_t len) {
-    Text = Text.substr(len);
-  }
-
-  /// Claim and return all the rest of the characters.
-  StringRef getString() {
-    auto result = Text;
-    advanceOffset(Text.size());
-    return result;
-  }
-
-  bool readUntil(char c, std::string &result) {
-    llvm::Optional<char> c2;
-    while (!isEmpty() && (c2 = peek()).getValue() != c) {
-      result.push_back(c2.getValue());
-      advanceOffset(1);
-    }
-    return c2.hasValue() && c2.getValue() == c;
-  }
-};
-
-/// The main class for parsing a demangling tree out of a mangled string.
-class OldDemangler {
-  std::vector<NodePointer> Substitutions;
-  NameSource Mangled;
-  NodeFactory &Factory;
-public:  
-  OldDemangler(llvm::StringRef mangled, NodeFactory &Factory)
-    : Mangled(mangled), Factory(Factory) {}
-
-/// Try to demangle a child node of the given kind.  If that fails,
-/// return; otherwise add it to the parent.
-#define DEMANGLE_CHILD_OR_RETURN(PARENT, CHILD_KIND) do { \
-    auto _node = demangle##CHILD_KIND();                  \
-    if (!_node) return nullptr;                           \
-    addChild(PARENT, _node);                              \
-  } while (false)
-
-/// Try to demangle a child node of the given kind.  If that fails,
-/// return; otherwise add it to the parent.
-#define DEMANGLE_CHILD_AS_NODE_OR_RETURN(PARENT, CHILD_KIND) do {  \
-    auto _kind = demangle##CHILD_KIND();                           \
-    if (!_kind.hasValue()) return nullptr;                         \
-    addChild(PARENT, Factory.createNode(Node::Kind::CHILD_KIND,        \
-                                           unsigned(*_kind)));     \
-  } while (false)
-
-  /// Attempt to demangle the source string.  The root node will
-  /// always be a Global.  Extra characters at the end will be
-  /// tolerated (and included as a Suffix node as a child of the
-  /// Global).
-  ///
-  /// \return true if the mangling succeeded
-  NodePointer demangleTopLevel() {
-    if (!Mangled.nextIf("_T"))
-      return nullptr;
-
-    NodePointer topLevel = Factory.createNode(Node::Kind::Global);
-
-    // First demangle any specialization prefixes.
-    if (Mangled.nextIf("TS")) {
-      do {
-        DEMANGLE_CHILD_OR_RETURN(topLevel, SpecializedAttribute);
-
-        // The Substitution header does not share state with the rest
-        // of the mangling.
-        Substitutions.clear();
-      } while (Mangled.nextIf("_TTS"));
-
-      // Then check that we have a global.
-      if (!Mangled.nextIf("_T"))
-        return nullptr;
-
-    } else if (Mangled.nextIf("To")) {
-      addChild(topLevel, Factory.createNode(Node::Kind::ObjCAttribute));
-    } else if (Mangled.nextIf("TO")) {
-      addChild(topLevel, Factory.createNode(Node::Kind::NonObjCAttribute));
-    } else if (Mangled.nextIf("TD")) {
-      addChild(topLevel, Factory.createNode(Node::Kind::DynamicAttribute));
-    } else if (Mangled.nextIf("Td")) {
-      addChild(topLevel, Factory.createNode(
-                          Node::Kind::DirectMethodReferenceAttribute));
-    } else if (Mangled.nextIf("TV")) {
-      addChild(topLevel, Factory.createNode(Node::Kind::VTableAttribute));
-    }
-
-    DEMANGLE_CHILD_OR_RETURN(topLevel, Global);
-
-    // Add a suffix node if there's anything left unmangled.
-    if (!Mangled.isEmpty()) {
-      addChild(topLevel, Factory.createNode(Node::Kind::Suffix,
-                                        Mangled.getString()));
-    }
-
-    return topLevel;
-  }
-
-  NodePointer demangleTypeName() {
-    return demangleType();
-  }
-  
-private:
-  enum class IsVariadic {
-    yes = true, no = false
-  };
-
-  void addChild(NodePointer Parent, NodePointer Child) {
-    Parent->addChild(Child, Factory);
-  }
-  
-  llvm::Optional<Directness> demangleDirectness() {
-    if (Mangled.nextIf('d'))
-      return Directness::Direct;
-    if (Mangled.nextIf('i'))
-      return Directness::Indirect;
-    return llvm::None;
-  }
-
-  bool demangleNatural(Node::IndexType &num) {
-    if (!Mangled)
-      return false;
-    char c = Mangled.next();
-    if (c < '0' || c > '9')
-      return false;
-    num = (c - '0');
-    while (true) {
-      if (!Mangled) {
-        return true;
-      }
-      c = Mangled.peek();
-      if (c < '0' || c > '9') {
-        return true;
-      } else {
-        num = (10 * num) + (c - '0');
-      }
-      Mangled.next();
-    }
-  }
-
-  bool demangleBuiltinSize(Node::IndexType &num) {
-    if (!demangleNatural(num))
-      return false;
-    if (Mangled.nextIf('_'))
-      return true;
-    return false;
-  }
-
-  llvm::Optional<ValueWitnessKind> demangleValueWitnessKind() {
-    char Code[2];
-    if (!Mangled)
-      return llvm::None;
-    Code[0] = Mangled.next();
-    if (!Mangled)
-      return llvm::None;
-    Code[1] = Mangled.next();
-
-    StringRef CodeStr(Code, 2);
-#define VALUE_WITNESS(MANGLING, NAME) \
-  if (CodeStr == #MANGLING) return ValueWitnessKind::NAME;
-#include "swift/Demangling/ValueWitnessMangling.def"
-
-    return llvm::None;
-  }
-
-  NodePointer demangleGlobal() {
-    if (!Mangled)
-      return nullptr;
-
-    // Type metadata.
-    if (Mangled.nextIf('M')) {
-      if (Mangled.nextIf('P')) {
-        auto pattern =
-            Factory.createNode(Node::Kind::GenericTypeMetadataPattern);
-        DEMANGLE_CHILD_OR_RETURN(pattern, Type);
-        return pattern;
-      }
-      if (Mangled.nextIf('a')) {
-        auto accessor =
-          Factory.createNode(Node::Kind::TypeMetadataAccessFunction);
-        DEMANGLE_CHILD_OR_RETURN(accessor, Type);
-        return accessor;
-      }
-      if (Mangled.nextIf('L')) {
-        auto cache = Factory.createNode(Node::Kind::TypeMetadataLazyCache);
-        DEMANGLE_CHILD_OR_RETURN(cache, Type);
-        return cache;
-      }
-      if (Mangled.nextIf('m')) {
-        auto metaclass = Factory.createNode(Node::Kind::Metaclass);
-        DEMANGLE_CHILD_OR_RETURN(metaclass, Type);
-        return metaclass;
-      }
-      if (Mangled.nextIf('n')) {
-        auto nominalType =
-            Factory.createNode(Node::Kind::NominalTypeDescriptor);
-        DEMANGLE_CHILD_OR_RETURN(nominalType, Type);
-        return nominalType;
-      }
-      if (Mangled.nextIf('f')) {
-        auto metadata = Factory.createNode(Node::Kind::FullTypeMetadata);
-        DEMANGLE_CHILD_OR_RETURN(metadata, Type);
-        return metadata;
-      }
-      if (Mangled.nextIf('p')) {
-        auto metadata = Factory.createNode(Node::Kind::ProtocolDescriptor);
-        DEMANGLE_CHILD_OR_RETURN(metadata, ProtocolName);
-        return metadata;
-      }
-      auto metadata = Factory.createNode(Node::Kind::TypeMetadata);
-      DEMANGLE_CHILD_OR_RETURN(metadata, Type);
-      return metadata;
-    }
-
-    // Partial application thunks.
-    if (Mangled.nextIf("PA")) {
-      Node::Kind kind = Node::Kind::PartialApplyForwarder;
-      if (Mangled.nextIf('o'))
-        kind = Node::Kind::PartialApplyObjCForwarder;
-      auto forwarder = Factory.createNode(kind);
-      if (Mangled.nextIf("__T"))
-        DEMANGLE_CHILD_OR_RETURN(forwarder, Global);
-      return forwarder;
-    }
-
-    // Top-level types, for various consumers.
-    if (Mangled.nextIf('t')) {
-      auto type = Factory.createNode(Node::Kind::TypeMangling);
-      DEMANGLE_CHILD_OR_RETURN(type, Type);
-      return type;
-    }
-
-    // Value witnesses.
-    if (Mangled.nextIf('w')) {
-      llvm::Optional<ValueWitnessKind> w = demangleValueWitnessKind();
-      if (!w.hasValue())
-        return nullptr;
-      auto witness =
-        Factory.createNode(Node::Kind::ValueWitness);
-      NodePointer Idx = Factory.createNode(Node::Kind::Index,
-                                           unsigned(w.getValue()));
-      witness->addChild(Idx, Factory);
-      DEMANGLE_CHILD_OR_RETURN(witness, Type);
-      return witness;
-    }
-
-    // Offsets, value witness tables, and protocol witnesses.
-    if (Mangled.nextIf('W')) {
-      if (Mangled.nextIf('V')) {
-        auto witnessTable = Factory.createNode(Node::Kind::ValueWitnessTable);
-        DEMANGLE_CHILD_OR_RETURN(witnessTable, Type);
-        return witnessTable;
-      }
-      if (Mangled.nextIf('v')) {
-        auto fieldOffset = Factory.createNode(Node::Kind::FieldOffset);
-        DEMANGLE_CHILD_AS_NODE_OR_RETURN(fieldOffset, Directness);
-        DEMANGLE_CHILD_OR_RETURN(fieldOffset, Entity);
-        return fieldOffset;
-      }
-      if (Mangled.nextIf('P')) {
-        auto witnessTable =
-            Factory.createNode(Node::Kind::ProtocolWitnessTable);
-        DEMANGLE_CHILD_OR_RETURN(witnessTable, ProtocolConformance);
-        return witnessTable;
-      }
-      if (Mangled.nextIf('G')) {
-        auto witnessTable =
-            Factory.createNode(Node::Kind::GenericProtocolWitnessTable);
-        DEMANGLE_CHILD_OR_RETURN(witnessTable, ProtocolConformance);
-        return witnessTable;
-      }
-      if (Mangled.nextIf('I')) {
-        auto witnessTable = Factory.createNode(
-            Node::Kind::GenericProtocolWitnessTableInstantiationFunction);
-        DEMANGLE_CHILD_OR_RETURN(witnessTable, ProtocolConformance);
-        return witnessTable;
-      }
-      if (Mangled.nextIf('l')) {
-        auto accessor =
-          Factory.createNode(Node::Kind::LazyProtocolWitnessTableAccessor);
-        DEMANGLE_CHILD_OR_RETURN(accessor, Type);
-        DEMANGLE_CHILD_OR_RETURN(accessor, ProtocolConformance);
-        return accessor;
-      }
-      if (Mangled.nextIf('L')) {
-        auto accessor =
-          Factory.createNode(Node::Kind::LazyProtocolWitnessTableCacheVariable);
-        DEMANGLE_CHILD_OR_RETURN(accessor, Type);
-        DEMANGLE_CHILD_OR_RETURN(accessor, ProtocolConformance);
-        return accessor;
-      }
-      if (Mangled.nextIf('a')) {
-        auto tableTemplate =
-          Factory.createNode(Node::Kind::ProtocolWitnessTableAccessor);
-        DEMANGLE_CHILD_OR_RETURN(tableTemplate, ProtocolConformance);
-        return tableTemplate;
-      }
-      if (Mangled.nextIf('t')) {
-        auto accessor = Factory.createNode(
-            Node::Kind::AssociatedTypeMetadataAccessor);
-        DEMANGLE_CHILD_OR_RETURN(accessor, ProtocolConformance);
-        DEMANGLE_CHILD_OR_RETURN(accessor, DeclName);
-        return accessor;
-      }
-      if (Mangled.nextIf('T')) {
-        auto accessor = Factory.createNode(
-            Node::Kind::AssociatedTypeWitnessTableAccessor);
-        DEMANGLE_CHILD_OR_RETURN(accessor, ProtocolConformance);
-        DEMANGLE_CHILD_OR_RETURN(accessor, DeclName);
-        DEMANGLE_CHILD_OR_RETURN(accessor, ProtocolName);
-        return accessor;
-      }
-      return nullptr;
-    }
-
-    // Other thunks.
-    if (Mangled.nextIf('T')) {
-      if (Mangled.nextIf('R')) {
-        auto thunk = Factory.createNode(Node::Kind::ReabstractionThunkHelper);
-        if (!demangleReabstractSignature(thunk))
-          return nullptr;
-        return thunk;
-      }
-      if (Mangled.nextIf('r')) {
-        auto thunk = Factory.createNode(Node::Kind::ReabstractionThunk);
-        if (!demangleReabstractSignature(thunk))
-          return nullptr;
-        return thunk;
-      }
-      if (Mangled.nextIf('W')) {
-        NodePointer thunk = Factory.createNode(Node::Kind::ProtocolWitness);
-        DEMANGLE_CHILD_OR_RETURN(thunk, ProtocolConformance);
-        // The entity is mangled in its own generic context.
-        DEMANGLE_CHILD_OR_RETURN(thunk, Entity);
-        return thunk;
-      }
-      return nullptr;
-    }
-
-    // Everything else is just an entity.
-    return demangleEntity();
-  }
-
-  NodePointer demangleGenericSpecialization(NodePointer specialization) {
-    while (!Mangled.nextIf('_')) {
-      // Otherwise, we have another parameter. Demangle the type.
-      NodePointer param = Factory.createNode(Node::Kind::GenericSpecializationParam);
-      DEMANGLE_CHILD_OR_RETURN(param, Type);
-
-      // Then parse any conformances until we find an underscore. Pop off the
-      // underscore since it serves as the end of our mangling list.
-      while (!Mangled.nextIf('_')) {
-        DEMANGLE_CHILD_OR_RETURN(param, ProtocolConformance);
-      }
-
-      // Add the parameter to our specialization list.
-      specialization->addChild(param, Factory);
-    }
-
-    return specialization;
-  }
-
-/// TODO: This is an atrocity. Come up with a shorter name.
-#define FUNCSIGSPEC_CREATE_PARAM_KIND(kind)                                    \
-  Factory.createNode(                                                          \
-      Node::Kind::FunctionSignatureSpecializationParamKind,                    \
-      Node::IndexType(FunctionSigSpecializationParamKind::kind))
-
-#define FUNCSIGSPEC_CREATE_PARAM_PAYLOAD(payload)                              \
-  Factory.createNode(Node::Kind::FunctionSignatureSpecializationParamPayload,  \
-                     payload)
-
-  bool demangleFuncSigSpecializationConstantProp(NodePointer parent) {
-    // Then figure out what was actually constant propagated. First check if
-    // we have a function.
-    if (Mangled.nextIf("fr")) {
-      // Demangle the identifier
-      NodePointer name = demangleIdentifier();
-      if (!name || !Mangled.nextIf('_'))
-        return false;
-      parent->addChild(FUNCSIGSPEC_CREATE_PARAM_KIND(ConstantPropFunction), Factory);
-      parent->addChild(FUNCSIGSPEC_CREATE_PARAM_PAYLOAD(name->getText()), Factory);
-      return true;
-    }
-
-    if (Mangled.nextIf('g')) {
-      NodePointer name = demangleIdentifier();
-      if (!name || !Mangled.nextIf('_'))
-        return false;
-      parent->addChild(FUNCSIGSPEC_CREATE_PARAM_KIND(ConstantPropGlobal), Factory);
-      parent->addChild(FUNCSIGSPEC_CREATE_PARAM_PAYLOAD(name->getText()), Factory);
-      return true;
-    }
-
-    if (Mangled.nextIf('i')) {
-      std::string Str;
-      if (!Mangled.readUntil('_', Str) || !Mangled.nextIf('_'))
-        return false;
-      parent->addChild(FUNCSIGSPEC_CREATE_PARAM_KIND(ConstantPropInteger), Factory);
-      parent->addChild(FUNCSIGSPEC_CREATE_PARAM_PAYLOAD(Str), Factory);
-      return true;
-    }
-
-    if (Mangled.nextIf("fl")) {
-      std::string Str;
-      if (!Mangled.readUntil('_', Str) || !Mangled.nextIf('_'))
-        return false;
-      parent->addChild(FUNCSIGSPEC_CREATE_PARAM_KIND(ConstantPropFloat), Factory);
-      parent->addChild(FUNCSIGSPEC_CREATE_PARAM_PAYLOAD(Str), Factory);
-      return true;
-    }
-
-    if (Mangled.nextIf("s")) {
-      // Skip: 'e' encoding 'v' str. encoding is a 0 or 1 and str is a string of
-      // length less than or equal to 32. We do not specialize strings with a
-      // length greater than 32.
-      if (!Mangled.nextIf('e'))
-        return false;
-      char encoding = Mangled.peek();
-      if (encoding != '0' && encoding != '1')
-        return false;
-      std::string encodingStr;
-      if (encoding == '0')
-        encodingStr += "u8";
-      else
-        encodingStr += "u16";
-      Mangled.advanceOffset(1);
-
-      if (!Mangled.nextIf('v'))
-        return false;
-      NodePointer str = demangleIdentifier();
-      if (!str || !Mangled.nextIf('_'))
-        return false;
-
-      parent->addChild(FUNCSIGSPEC_CREATE_PARAM_KIND(ConstantPropString), Factory);
-      parent->addChild(FUNCSIGSPEC_CREATE_PARAM_PAYLOAD(encodingStr), Factory);
-      parent->addChild(FUNCSIGSPEC_CREATE_PARAM_PAYLOAD(str->getText()), Factory);
-      return true;
-    }
-
-    // Unknown constant prop specialization
-    return false;
-  }
-
-  bool demangleFuncSigSpecializationClosureProp(NodePointer parent) {
-    // We don't actually demangle the function or types for now. But we do want
-    // to signal that we specialized a closure.
-
-    NodePointer name = demangleIdentifier();
-    if (!name) {
-      return false;
-    }
-
-    parent->addChild(FUNCSIGSPEC_CREATE_PARAM_KIND(ClosureProp), Factory);
-    parent->addChild(FUNCSIGSPEC_CREATE_PARAM_PAYLOAD(name->getText()), Factory);
-
-    // Then demangle types until we fail.
-    NodePointer type = nullptr;
-    while (Mangled.peek() != '_' && (type = demangleType())) {
-      parent->addChild(type, Factory);
-    }
-
-    // Eat last '_'
-    if (!Mangled.nextIf('_'))
-      return false;
-
-    return true;
-  }
-
-  NodePointer
-  demangleFunctionSignatureSpecialization(NodePointer specialization) {
-    // Until we hit the last '_' in our specialization info...
-    while (!Mangled.nextIf('_')) {
-      // Create the parameter.
-      NodePointer param =
-        Factory.createNode(Node::Kind::FunctionSignatureSpecializationParam);
-
-      // First handle options.
-      if (Mangled.nextIf("n_")) {
-        // Leave the parameter empty.
-      } else if (Mangled.nextIf("cp")) {
-        if (!demangleFuncSigSpecializationConstantProp(param))
-          return nullptr;
-      } else if (Mangled.nextIf("cl")) {
-        if (!demangleFuncSigSpecializationClosureProp(param))
-          return nullptr;
-      } else if (Mangled.nextIf("i_")) {
-        auto result = FUNCSIGSPEC_CREATE_PARAM_KIND(BoxToValue);
-        if (!result)
-          return nullptr;
-        param->addChild(result, Factory);
-      } else if (Mangled.nextIf("k_")) {
-        auto result = FUNCSIGSPEC_CREATE_PARAM_KIND(BoxToStack);
-        if (!result)
-          return nullptr;
-        param->addChild(result, Factory);
-      } else {
-        // Otherwise handle option sets.
-        unsigned Value = 0;
-        if (Mangled.nextIf('d')) {
-          Value |=
-            unsigned(FunctionSigSpecializationParamKind::Dead);
-        }
-
-        if (Mangled.nextIf('g')) {
-          Value |=
-              unsigned(FunctionSigSpecializationParamKind::OwnedToGuaranteed);
-        }
-
-        if (Mangled.nextIf('o')) {
-          Value |=
-              unsigned(FunctionSigSpecializationParamKind::GuaranteedToOwned);
-        }
-
-        if (Mangled.nextIf('s')) {
-          Value |= unsigned(FunctionSigSpecializationParamKind::SROA);
-        }
-
-        if (!Mangled.nextIf('_'))
-          return nullptr;
-
-        if (!Value)
-          return nullptr;
-
-        auto result = Factory.createNode(
-            Node::Kind::FunctionSignatureSpecializationParamKind, Value);
-        if (!result)
-          return nullptr;
-        param->addChild(result, Factory);
-      }
-
-      specialization->addChild(param, Factory);
-    }
-
-    return specialization;
-  }
-
-#undef FUNCSIGSPEC_CREATE_PARAM_KIND
-#undef FUNCSIGSPEC_CREATE_PARAM_PAYLOAD
-
-  NodePointer demangleSpecializedAttribute() {
-    bool isNotReAbstracted = false;
-    if (Mangled.nextIf("g") || (isNotReAbstracted = Mangled.nextIf("r"))) {
-      auto spec = Factory.createNode(isNotReAbstracted ?
-                              Node::Kind::GenericSpecializationNotReAbstracted :
-                              Node::Kind::GenericSpecialization);
-
-      // Create a node if the specialization is serialized.
-      if (Mangled.nextIf("q")) {
-        auto kind = Node::Kind::IsSerialized;
-        spec->addChild(Factory.createNode(kind), Factory);
-      }
-
-      // Create a node for the pass id.
-      spec->addChild(Factory.createNode(Node::Kind::SpecializationPassID,
-                                      unsigned(Mangled.next() - 48)), Factory);
-
-      // And then mangle the generic specialization.
-      return demangleGenericSpecialization(spec);
-    }
-    if (Mangled.nextIf("f")) {
-      auto spec =
-          Factory.createNode(Node::Kind::FunctionSignatureSpecialization);
-
-      // Create a node if the specialization is serialized.
-      if (Mangled.nextIf("q")) {
-        auto kind = Node::Kind::IsSerialized;
-        spec->addChild(Factory.createNode(kind), Factory);
-      }
-
-      // Add the pass id.
-      spec->addChild(Factory.createNode(Node::Kind::SpecializationPassID,
-                                      unsigned(Mangled.next() - 48)), Factory);
-
-      // Then perform the function signature specialization.
-      return demangleFunctionSignatureSpecialization(spec);
-    }
-
-    // We don't know how to handle this specialization.
-    return nullptr;
-  }
-  
-  NodePointer demangleDeclName() {
-    // decl-name ::= local-decl-name
-    // local-decl-name ::= 'L' index identifier
-    if (Mangled.nextIf('L')) {
-      NodePointer discriminator = demangleIndexAsNode();
-      if (!discriminator) return nullptr;
-
-      NodePointer name = demangleIdentifier();
-      if (!name) return nullptr;
-
-      NodePointer localName = Factory.createNode(Node::Kind::LocalDeclName);
-      localName->addChild(discriminator, Factory);
-      localName->addChild(name, Factory);
-      return localName;
-
-    } else if (Mangled.nextIf('P')) {
-      NodePointer discriminator = demangleIdentifier();
-      if (!discriminator) return nullptr;
-
-      NodePointer name = demangleIdentifier();
-      if (!name) return nullptr;
-
-      auto privateName = Factory.createNode(Node::Kind::PrivateDeclName);
-      privateName->addChild(discriminator, Factory);
-      privateName->addChild(name, Factory);
-      return privateName;
-    }
-
-    // decl-name ::= identifier
-    return demangleIdentifier();
-  }
-
-  NodePointer demangleIdentifier(llvm::Optional<Node::Kind> kind = llvm::None) {
-    if (!Mangled)
-      return nullptr;
-    
-    bool isPunycoded = Mangled.nextIf('X');
-    std::string decodeBuffer;
-
-    auto decode = [&](StringRef s) -> StringRef {
-      if (!isPunycoded)
-        return s;
-      if (!Punycode::decodePunycodeUTF8(s, decodeBuffer))
-        return {};
-      return decodeBuffer;
-    };
-    
-    bool isOperator = false;
-    if (Mangled.nextIf('o')) {
-      isOperator = true;
-      // Operator identifiers aren't valid in the contexts that are
-      // building more specific identifiers.
-      if (kind.hasValue()) return nullptr;
-
-      char op_mode = Mangled.next();
-      switch (op_mode) {
-      case 'p':
-        kind = Node::Kind::PrefixOperator;
-        break;
-      case 'P':
-        kind = Node::Kind::PostfixOperator;
-        break;
-      case 'i':
-        kind = Node::Kind::InfixOperator;
-        break;
-      default:
-        return nullptr;
-      }
-    }
-
-    if (!kind.hasValue()) kind = Node::Kind::Identifier;
-
-    Node::IndexType length;
-    if (!demangleNatural(length))
-      return nullptr;
-    if (!Mangled.hasAtLeast(length))
-      return nullptr;
-    
-    StringRef identifier = Mangled.slice(length);
-    Mangled.advanceOffset(length);
-    
-    // Decode Unicode identifiers.
-    identifier = decode(identifier);
-    if (identifier.empty())
-      return nullptr;
-
-    // Decode operator names.
-    std::string opDecodeBuffer;
-    if (isOperator) {
-                                        // abcdefghijklmnopqrstuvwxyz
-      static const char op_char_table[] = "& @/= >    <*!|+?%-~   ^ .";
-
-      opDecodeBuffer.reserve(identifier.size());
-      for (signed char c : identifier) {
-        if (c < 0) {
-          // Pass through Unicode characters.
-          opDecodeBuffer.push_back(c);
-          continue;
-        }
-        if (c < 'a' || c > 'z')
-          return nullptr;
-        char o = op_char_table[c - 'a'];
-        if (o == ' ')
-          return nullptr;
-        opDecodeBuffer.push_back(o);
-      }
-      identifier = opDecodeBuffer;
-    }
-    
-    return Factory.createNode(*kind, identifier);
-  }
-
-  bool demangleIndex(Node::IndexType &natural) {
-    if (Mangled.nextIf('_')) {
-      natural = 0;
-      return true;
-    }
-    if (demangleNatural(natural)) {
-      if (!Mangled.nextIf('_'))
-        return false;
-      ++natural;
-      return true;
-    }
-    return false;
-  }
-
-  /// Demangle an <index> and package it as a node of some kind.
-  NodePointer demangleIndexAsNode(Node::Kind kind = Node::Kind::Number) {
-    Node::IndexType index;
-    if (!demangleIndex(index))
-      return nullptr;
-    return Factory.createNode(kind, index);
-  }
-
-  NodePointer createSwiftType(Node::Kind typeKind, StringRef name) {
-    NodePointer type = Factory.createNode(typeKind);
-    type->addChild(Factory.createNode(Node::Kind::Module, STDLIB_NAME), Factory);
-    type->addChild(Factory.createNode(Node::Kind::Identifier, name), Factory);
-    return type;
-  }
-
-  /// Demangle a <substitution>, given that we've already consumed the 'S'.
-  NodePointer demangleSubstitutionIndex() {
-    if (!Mangled)
-      return nullptr;
-    if (Mangled.nextIf('o'))
-      return Factory.createNode(Node::Kind::Module, MANGLING_MODULE_OBJC);
-    if (Mangled.nextIf('C'))
-      return Factory.createNode(Node::Kind::Module,
-                                MANGLING_MODULE_CLANG_IMPORTER);
-    if (Mangled.nextIf('a'))
-      return createSwiftType(Node::Kind::Structure, "Array");
-    if (Mangled.nextIf('b'))
-      return createSwiftType(Node::Kind::Structure, "Bool");
-    if (Mangled.nextIf('c'))
-      return createSwiftType(Node::Kind::Structure, "UnicodeScalar");
-    if (Mangled.nextIf('d'))
-      return createSwiftType(Node::Kind::Structure, "Double");
-    if (Mangled.nextIf('f'))
-      return createSwiftType(Node::Kind::Structure, "Float");
-    if (Mangled.nextIf('i'))
-      return createSwiftType(Node::Kind::Structure, "Int");
-    if (Mangled.nextIf('V'))
-      return createSwiftType(Node::Kind::Structure, "UnsafeRawPointer");
-    if (Mangled.nextIf('v'))
-      return createSwiftType(Node::Kind::Structure, "UnsafeMutableRawPointer");
-    if (Mangled.nextIf('P'))
-      return createSwiftType(Node::Kind::Structure, "UnsafePointer");
-    if (Mangled.nextIf('p'))
-      return createSwiftType(Node::Kind::Structure, "UnsafeMutablePointer");
-    if (Mangled.nextIf('q'))
-      return createSwiftType(Node::Kind::Enum, "Optional");
-    if (Mangled.nextIf('Q'))
-      return createSwiftType(Node::Kind::Enum, "ImplicitlyUnwrappedOptional");
-    if (Mangled.nextIf('R'))
-      return createSwiftType(Node::Kind::Structure, "UnsafeBufferPointer");
-    if (Mangled.nextIf('r'))
-      return createSwiftType(Node::Kind::Structure, "UnsafeMutableBufferPointer");
-    if (Mangled.nextIf('S'))
-      return createSwiftType(Node::Kind::Structure, "String");
-    if (Mangled.nextIf('u'))
-      return createSwiftType(Node::Kind::Structure, "UInt");
-    Node::IndexType index_sub;
-    if (!demangleIndex(index_sub))
-      return nullptr;
-    if (index_sub >= Substitutions.size())
-      return nullptr;
-    return Substitutions[index_sub];
-  }
-
-  NodePointer demangleModule() {
-    if (Mangled.nextIf('s')) {
-      return Factory.createNode(Node::Kind::Module, STDLIB_NAME);
-    }
-    if (Mangled.nextIf('S')) {
-      NodePointer module = demangleSubstitutionIndex();
-      if (!module)
-        return nullptr;
-      if (module->getKind() != Node::Kind::Module)
-        return nullptr;
-      return module;
-    }
-
-    NodePointer module = demangleIdentifier(Node::Kind::Module);
-    if (!module) return nullptr;
-    Substitutions.push_back(module);
-    return module;
-  }
-
-  NodePointer demangleDeclarationName(Node::Kind kind) {
-    NodePointer context = demangleContext();
-    if (!context) return nullptr;
-
-    auto name = demangleDeclName();
-    if (!name) return nullptr;
-
-    auto decl = Factory.createNode(kind);
-    decl->addChild(context, Factory);
-    decl->addChild(name, Factory);
-    Substitutions.push_back(decl);
-    return decl;
-  }
-
-  NodePointer demangleProtocolName() {
-    NodePointer proto = demangleProtocolNameImpl();
-    if (!proto) return nullptr;
-
-    NodePointer type = Factory.createNode(Node::Kind::Type);
-    type->addChild(proto, Factory);
-    return type;
-  }
-
-  NodePointer demangleProtocolNameGivenContext(NodePointer context) {
-    NodePointer name = demangleDeclName();
-    if (!name) return nullptr;
-
-    auto proto = Factory.createNode(Node::Kind::Protocol);
-    proto->addChild(context, Factory);
-    proto->addChild(name, Factory);
-    Substitutions.push_back(proto);
-    return proto;
-  }
-
-  NodePointer demangleProtocolNameImpl() {
-    // There's an ambiguity in <protocol> between a substitution of
-    // the protocol and a substitution of the protocol's context, so
-    // we have to duplicate some of the logic from
-    // demangleDeclarationName.
-    if (Mangled.nextIf('S')) {
-      NodePointer sub = demangleSubstitutionIndex();
-      if (!sub) return nullptr;
-      if (sub->getKind() == Node::Kind::Protocol)
-        return sub;
-
-      if (sub->getKind() != Node::Kind::Module)
-        return nullptr;
-
-      return demangleProtocolNameGivenContext(sub);
-    }
-
-    if (Mangled.nextIf('s')) {
-      NodePointer stdlib = Factory.createNode(Node::Kind::Module, STDLIB_NAME);
-
-      return demangleProtocolNameGivenContext(stdlib);
-    }
-
-    return demangleDeclarationName(Node::Kind::Protocol);
-  }
-
-  NodePointer demangleNominalType() {
-    if (Mangled.nextIf('S'))
-      return demangleSubstitutionIndex();
-    if (Mangled.nextIf('V'))
-      return demangleDeclarationName(Node::Kind::Structure);
-    if (Mangled.nextIf('O'))
-      return demangleDeclarationName(Node::Kind::Enum);
-    if (Mangled.nextIf('C'))
-      return demangleDeclarationName(Node::Kind::Class);
-    if (Mangled.nextIf('P'))
-      return demangleDeclarationName(Node::Kind::Protocol);
-    return nullptr;
-  }
-
-  NodePointer demangleBoundGenericArgs(NodePointer nominalType) {
-    if (nominalType->getNumChildren() == 0)
-      return nullptr;
-
-    // Generic arguments for the outermost type come first.
-    NodePointer parentOrModule = nominalType->getChild(0);
-
-    if (parentOrModule->getKind() != Node::Kind::Module &&
-        parentOrModule->getKind() != Node::Kind::Function &&
-        parentOrModule->getKind() != Node::Kind::Extension) {
-      parentOrModule = demangleBoundGenericArgs(parentOrModule);
-      if (!parentOrModule)
-        return nullptr;
-
-      // Rebuild this type with the new parent type, which may have
-      // had its generic arguments applied.
-      NodePointer result = Factory.createNode(nominalType->getKind());
-      result->addChild(parentOrModule, Factory);
-      result->addChild(nominalType->getChild(1), Factory);
-
-      nominalType = result;
-    }
-
-    NodePointer args = Factory.createNode(Node::Kind::TypeList);
-    while (!Mangled.nextIf('_')) {
-      NodePointer type = demangleType();
-      if (!type)
-        return nullptr;
-      args->addChild(type, Factory);
-      if (Mangled.isEmpty())
-        return nullptr;
-    }
-
-    // If there were no arguments at this level there is nothing left
-    // to do.
-    if (args->getNumChildren() == 0)
-      return nominalType;
-
-    // Otherwise, build a bound generic type node from the unbound
-    // type and arguments.
-    NodePointer unboundType = Factory.createNode(Node::Kind::Type);
-    unboundType->addChild(nominalType, Factory);
-
-    Node::Kind kind;
-    switch (nominalType->getKind()) { // look through Type node
-      case Node::Kind::Class:
-        kind = Node::Kind::BoundGenericClass;
-        break;
-      case Node::Kind::Structure:
-        kind = Node::Kind::BoundGenericStructure;
-        break;
-      case Node::Kind::Enum:
-        kind = Node::Kind::BoundGenericEnum;
-        break;
-      default:
-        return nullptr;
-    }
-    NodePointer result = Factory.createNode(kind);
-    result->addChild(unboundType, Factory);
-    result->addChild(args, Factory);
-    return result;
-  }
-
-  NodePointer demangleBoundGenericType() {
-    // bound-generic-type ::= 'G' nominal-type (args+ '_')+
-    //
-    // Each level of nominal type nesting has its own list of arguments.
-
-    NodePointer nominalType = demangleNominalType();
-    if (!nominalType)
-      return nullptr;
-
-    return demangleBoundGenericArgs(nominalType);
-  }
-
-  NodePointer demangleContext() {
-    // context ::= module
-    // context ::= entity
-    // context ::= 'E' module context (extension defined in a different module)
-    // context ::= 'e' module context generic-signature (constrained extension)
-    if (!Mangled) return nullptr;
-    if (Mangled.nextIf('E')) {
-      NodePointer ext = Factory.createNode(Node::Kind::Extension);
-      NodePointer def_module = demangleModule();
-      if (!def_module) return nullptr;
-      NodePointer type = demangleContext();
-      if (!type) return nullptr;
-      ext->addChild(def_module, Factory);
-      ext->addChild(type, Factory);
-      return ext;
-    }
-    if (Mangled.nextIf('e')) {
-      NodePointer ext = Factory.createNode(Node::Kind::Extension);
-      NodePointer def_module = demangleModule();
-      if (!def_module) return nullptr;
-      NodePointer sig = demangleGenericSignature();
-      // The generic context is currently re-specified by the type mangling.
-      // If we ever remove 'self' from manglings, we should stop resetting the
-      // context here.
-      if (!sig) return nullptr;
-      NodePointer type = demangleContext();
-      if (!type) return nullptr;
-
-      ext->addChild(def_module, Factory);
-      ext->addChild(type, Factory);
-      ext->addChild(sig, Factory);
-      return ext;
-    }
-    if (Mangled.nextIf('S'))
-      return demangleSubstitutionIndex();
-    if (Mangled.nextIf('s'))
-      return Factory.createNode(Node::Kind::Module, STDLIB_NAME);
-    if (Mangled.nextIf('G'))
-      return demangleBoundGenericType();
-    if (isStartOfEntity(Mangled.peek()))
-      return demangleEntity();
-    return demangleModule();
-  }
-  
-  NodePointer demangleProtocolList() {
-    NodePointer proto_list = Factory.createNode(Node::Kind::ProtocolList);
-    NodePointer type_list = Factory.createNode(Node::Kind::TypeList);
-    proto_list->addChild(type_list, Factory);
-    while (!Mangled.nextIf('_')) {
-      NodePointer proto = demangleProtocolName();
-      if (!proto)
-        return nullptr;
-      type_list->addChild(proto, Factory);
-    }
-    return proto_list;
-  }
-
-  NodePointer demangleProtocolConformance() {
-    NodePointer type = demangleType();
-    if (!type)
-      return nullptr;
-    NodePointer protocol = demangleProtocolName();
-    if (!protocol)
-      return nullptr;
-    NodePointer context = demangleContext();
-    if (!context)
-      return nullptr;
-    NodePointer proto_conformance =
-        Factory.createNode(Node::Kind::ProtocolConformance);
-    proto_conformance->addChild(type, Factory);
-    proto_conformance->addChild(protocol, Factory);
-    proto_conformance->addChild(context, Factory);
-    return proto_conformance;
-  }
-
-  // entity ::= entity-kind context entity-name
-  // entity ::= nominal-type
-  NodePointer demangleEntity() {
-    // static?
-    bool isStatic = Mangled.nextIf('Z');
-  
-    // entity-kind
-    Node::Kind entityBasicKind;
-    if (Mangled.nextIf('F')) {
-      entityBasicKind = Node::Kind::Function;
-    } else if (Mangled.nextIf('v')) {
-      entityBasicKind = Node::Kind::Variable;
-    } else if (Mangled.nextIf('I')) {
-      entityBasicKind = Node::Kind::Initializer;
-    } else if (Mangled.nextIf('i')) {
-      entityBasicKind = Node::Kind::Subscript;
-    } else {
-      return demangleNominalType();
-    }
-
-    NodePointer context = demangleContext();
-    if (!context) return nullptr;
-
-    // entity-name
-    Node::Kind entityKind;
-    bool hasType = true;
-    // Wrap the enclosed entity in a variable or subscript node
-    bool wrapEntity = false;
-    NodePointer name = nullptr;
-    if (Mangled.nextIf('D')) {
-      entityKind = Node::Kind::Deallocator;
-      hasType = false;
-    } else if (Mangled.nextIf('d')) {
-      entityKind = Node::Kind::Destructor;
-      hasType = false;
-    } else if (Mangled.nextIf('e')) {
-      entityKind = Node::Kind::IVarInitializer;
-      hasType = false;
-    } else if (Mangled.nextIf('E')) {
-      entityKind = Node::Kind::IVarDestroyer;
-      hasType = false;
-    } else if (Mangled.nextIf('C')) {
-      entityKind = Node::Kind::Allocator;
-    } else if (Mangled.nextIf('c')) {
-      entityKind = Node::Kind::Constructor;
-    } else if (Mangled.nextIf('a')) {
-      wrapEntity = true;
-      if (Mangled.nextIf('O')) {
-        entityKind = Node::Kind::OwningMutableAddressor;
-      } else if (Mangled.nextIf('o')) {
-        entityKind = Node::Kind::NativeOwningMutableAddressor;
-      } else if (Mangled.nextIf('p')) {
-        entityKind = Node::Kind::NativePinningMutableAddressor;
-      } else if (Mangled.nextIf('u')) {
-        entityKind = Node::Kind::UnsafeMutableAddressor;
-      } else {
-        return nullptr;
-      }
-      name = demangleDeclName();
-      if (!name) return nullptr;
-    } else if (Mangled.nextIf('l')) {
-      wrapEntity = true;
-      if (Mangled.nextIf('O')) {
-        entityKind = Node::Kind::OwningAddressor;
-      } else if (Mangled.nextIf('o')) {
-        entityKind = Node::Kind::NativeOwningAddressor;
-      } else if (Mangled.nextIf('p')) {
-        entityKind = Node::Kind::NativePinningAddressor;
-      } else if (Mangled.nextIf('u')) {
-        entityKind = Node::Kind::UnsafeAddressor;
-      } else {
-        return nullptr;
-      }
-      name = demangleDeclName();
-      if (!name) return nullptr;
-    } else if (Mangled.nextIf('g')) {
-      wrapEntity = true;
-      entityKind = Node::Kind::Getter;
-      name = demangleDeclName();
-      if (!name) return nullptr;
-    } else if (Mangled.nextIf('G')) {
-      wrapEntity = true;
-      entityKind = Node::Kind::GlobalGetter;
-      name = demangleDeclName();
-      if (!name) return nullptr;
-    } else if (Mangled.nextIf('s')) {
-      wrapEntity = true;
-      entityKind = Node::Kind::Setter;
-      name = demangleDeclName();
-      if (!name) return nullptr;
-    } else if (Mangled.nextIf('m')) {
-      wrapEntity = true;
-      entityKind = Node::Kind::MaterializeForSet;
-      name = demangleDeclName();
-      if (!name) return nullptr;
-    } else if (Mangled.nextIf('w')) {
-      wrapEntity = true;
-      entityKind = Node::Kind::WillSet;
-      name = demangleDeclName();
-      if (!name) return nullptr;
-    } else if (Mangled.nextIf('W')) {
-      wrapEntity = true;
-      entityKind = Node::Kind::DidSet;
-      name = demangleDeclName();
-      if (!name) return nullptr;
-    } else if (Mangled.nextIf('r')) {
-      wrapEntity = true;
-      entityKind = Node::Kind::ReadAccessor;
-      name = demangleDeclName();
-      if (!name) return nullptr;
-    } else if (Mangled.nextIf('M')) {
-      wrapEntity = true;
-      entityKind = Node::Kind::ModifyAccessor;
-      name = demangleDeclName();
-      if (!name) return nullptr;
-    } else if (Mangled.nextIf('U')) {
-      entityKind = Node::Kind::ExplicitClosure;
-      name = demangleIndexAsNode();
-      if (!name) return nullptr;
-    } else if (Mangled.nextIf('u')) {
-      entityKind = Node::Kind::ImplicitClosure;
-      name = demangleIndexAsNode();
-      if (!name) return nullptr;
-    } else if (entityBasicKind == Node::Kind::Initializer) {
-      // entity-name ::= 'A' index
-      if (Mangled.nextIf('A')) {
-        entityKind = Node::Kind::DefaultArgumentInitializer;
-        name = demangleIndexAsNode();
-        if (!name) return nullptr;
-      // entity-name ::= 'i'
-      } else if (Mangled.nextIf('i')) {
-        entityKind = Node::Kind::Initializer;
-      } else {
-        return nullptr;
-      }
-      hasType = false;
-    } else {
-      entityKind = entityBasicKind;
-      name = demangleDeclName();
-      if (!name) return nullptr;
-    }
-
-    NodePointer entity = Factory.createNode(entityKind);
-    if (wrapEntity) {
-      // Create a subscript or variable node and make it the accessor's child
-      NodePointer wrappedEntity;
-      bool isSubscript = false;
-
-      // Rewrite the subscript's name to match the new mangling scheme
-      switch (name->getKind()) {
-        case Node::Kind::Identifier:
-          if (name->getText() == "subscript") {
-            isSubscript = true;
-            // Subscripts have no 'subscript' identifier name
-            name = nullptr;
-          }
-          break;
-        case Node::Kind::PrivateDeclName: // identifier file-discriminator?
-          if (name->getNumChildren() > 1 &&
-              name->getChild(1)->getText() == "subscript") {
-            isSubscript = true;
-
-            auto discriminator = name->getChild(0);
-
-            // Create new PrivateDeclName with no 'subscript' identifier child
-            name = Factory.createNode(Node::Kind::PrivateDeclName);
-            name->addChild(discriminator, Factory);
-          }
-          break;
-        default:
-          break;
-      }
-
-      // Create wrapped entity node
-      if (isSubscript) {
-        wrappedEntity = Factory.createNode(Node::Kind::Subscript);
-      } else {
-        wrappedEntity = Factory.createNode(Node::Kind::Variable);
-      }
-      wrappedEntity->addChild(context, Factory);
-
-      // Variables mangle their name before their type
-      if (!isSubscript)
-        wrappedEntity->addChild(name, Factory);
-
-      if (hasType) {
-        auto type = demangleType();
-        if (!type) return nullptr;
-        wrappedEntity->addChild(type, Factory);
-      }
-
-      // Subscripts mangle their file-discriminator after the type
-      if (isSubscript && name)
-        wrappedEntity->addChild(name, Factory);
-
-      entity->addChild(wrappedEntity, Factory);
-    } else {
-      entity->addChild(context, Factory);
-
-      if (name) entity->addChild(name, Factory);
-
-      if (hasType) {
-        auto type = demangleType();
-        if (!type) return nullptr;
-        entity->addChild(type, Factory);
-      }
-    }
-    
-    if (isStatic) {
-      auto staticNode = Factory.createNode(Node::Kind::Static);
-      staticNode->addChild(entity, Factory);
-      return staticNode;
-    }
-
-    return entity;
-  }
-
-  NodePointer getDependentGenericParamType(unsigned depth, unsigned index) {
-    DemanglerPrinter PrintName;
-    PrintName << genericParameterName(depth, index);
-
-    auto paramTy = Factory.createNode(Node::Kind::DependentGenericParamType);
-    paramTy->addChild(Factory.createNode(Node::Kind::Index, depth), Factory);
-    paramTy->addChild(Factory.createNode(Node::Kind::Index, index), Factory);
-
-    return paramTy;
-  }
-
-  NodePointer demangleGenericParamIndex() {
-    Node::IndexType depth, index;
-
-    if (Mangled.nextIf('d')) {
-      if (!demangleIndex(depth))
-        return nullptr;
-      depth += 1;
-      if (!demangleIndex(index))
-        return nullptr;
-    } else if (Mangled.nextIf('x')) {
-      depth = 0;
-      index = 0;
-    } else {
-      if (!demangleIndex(index))
-        return nullptr;
-      depth = 0;
-      index += 1;
-    }
-    return getDependentGenericParamType(depth, index);
-  }
-
-  NodePointer demangleDependentMemberTypeName(NodePointer base) {
-    assert(base->getKind() == Node::Kind::Type
-           && "base should be a type");
-    NodePointer assocTy = nullptr;
-
-    if (Mangled.nextIf('S')) {
-      assocTy = demangleSubstitutionIndex();
-      if (!assocTy)
-        return nullptr;
-      if (assocTy->getKind() != Node::Kind::DependentAssociatedTypeRef)
-        return nullptr;
-    } else {
-      NodePointer protocol = nullptr;
-      if (Mangled.nextIf('P')) {
-        protocol = demangleProtocolName();
-        if (!protocol) return nullptr;
-      }
-
-      // TODO: If the protocol name was elided from the assoc type mangling,
-      // we could try to fish it out of the generic signature constraints on the
-      // base.
-      NodePointer ID = demangleIdentifier();
-      if (!ID) return nullptr;
-      assocTy = Factory.createNode(Node::Kind::DependentAssociatedTypeRef);
-      if (!assocTy) return nullptr;
-      assocTy->addChild(ID, Factory);
-      if (protocol)
-        assocTy->addChild(protocol, Factory);
-
-      Substitutions.push_back(assocTy);
-    }
-
-    NodePointer depTy = Factory.createNode(Node::Kind::DependentMemberType);
-    depTy->addChild(base, Factory);
-    depTy->addChild(assocTy, Factory);
-    return depTy;
-  }
-
-  NodePointer demangleAssociatedTypeSimple() {
-    // Demangle the base type.
-    auto base = demangleGenericParamIndex();
-    if (!base)
-      return nullptr;
-
-    NodePointer nodeType = Factory.createNode(Node::Kind::Type);
-    nodeType->addChild(base, Factory);
-
-    // Demangle the associated type name.
-    return demangleDependentMemberTypeName(nodeType);
-  }
-  
-  NodePointer demangleAssociatedTypeCompound() {
-    // Demangle the base type.
-    auto base = demangleGenericParamIndex();
-    if (!base)
-      return nullptr;
-
-    // Demangle the associated type chain.
-    while (!Mangled.nextIf('_')) {
-      NodePointer nodeType = Factory.createNode(Node::Kind::Type);
-      nodeType->addChild(base, Factory);
-      
-      base = demangleDependentMemberTypeName(nodeType);
-      if (!base)
-        return nullptr;
-    }
-
-    return base;
-  }
-  
-  NodePointer demangleDependentType() {
-    if (!Mangled)
-      return nullptr;
-
-    // A dependent member type begins with a non-index, non-'d' character.
-    auto c = Mangled.peek();
-    if (c != 'd' && c != '_' && !Mangle::isDigit(c)) {
-      NodePointer baseType = demangleType();
-      if (!baseType) return nullptr;
-      return demangleDependentMemberTypeName(baseType);
-    }
-    
-    // Otherwise, we have a generic parameter.
-    return demangleGenericParamIndex();
-  }
-
-  NodePointer demangleConstrainedTypeImpl() {
-    // The constrained type can only be a generic parameter or an associated
-    // type thereof. The 'q' introducer is thus left off of generic params.
-    if (Mangled.nextIf('w')) {
-      return demangleAssociatedTypeSimple();
-    }
-    if (Mangled.nextIf('W')) {
-      return demangleAssociatedTypeCompound();
-    }
-    return demangleGenericParamIndex();
-  }
-
-  NodePointer demangleConstrainedType() {
-    auto type = demangleConstrainedTypeImpl();
-    if (!type)
-      return nullptr;
-
-    NodePointer nodeType = Factory.createNode(Node::Kind::Type);
-    nodeType->addChild(type, Factory);
-    return nodeType;
-  }
-
-  NodePointer demangleGenericSignature(bool isPseudogeneric = false) {
-    auto sig =
-      Factory.createNode(isPseudogeneric
-                            ? Node::Kind::DependentPseudogenericSignature
-                            : Node::Kind::DependentGenericSignature);
-    // First read in the parameter counts at each depth.
-    Node::IndexType count = ~(Node::IndexType)0;
-    
-    auto addCount = [&]{
-      auto countNode =
-        Factory.createNode(Node::Kind::DependentGenericParamCount, count);
-      sig->addChild(countNode, Factory);
-    };
-    
-    while (Mangled.peek() != 'R' && Mangled.peek() != 'r') {
-      if (Mangled.nextIf('z')) {
-        count = 0;
-      } else if (demangleIndex(count)) {
-        count += 1;
-      } else {
-        return nullptr;
-      }
-      addCount();
-    }
-    
-    // No mangled parameters means we have exactly one.
-    if (count == ~(Node::IndexType)0) {
-      count = 1;
-      addCount();
-    }
-    
-    // Next read in the generic requirements, if any.
-    if (Mangled.nextIf('r'))
-      return sig;
-    
-    if (!Mangled.nextIf('R'))
-      return nullptr;
-    
-    while (!Mangled.nextIf('r')) {
-      NodePointer reqt = demangleGenericRequirement();
-      if (!reqt) return nullptr;
-      sig->addChild(reqt, Factory);
-    }
-    
-    return sig;
-  }
-
-  NodePointer demangleMetatypeRepresentation() {
-    if (Mangled.nextIf('t'))
-      return Factory.createNode(Node::Kind::MetatypeRepresentation, "@thin");
-
-    if (Mangled.nextIf('T'))
-      return Factory.createNode(Node::Kind::MetatypeRepresentation, "@thick");
-
-    if (Mangled.nextIf('o'))
-      return Factory.createNode(Node::Kind::MetatypeRepresentation,
-                                 "@objc_metatype");
-
-    // Unknown metatype representation
-    return nullptr;
-  }
-  
-  NodePointer demangleGenericRequirement() {
-    NodePointer constrainedType = demangleConstrainedType();
-    if (!constrainedType)
-      return nullptr;
-    if (Mangled.nextIf('z')) {
-      NodePointer second = demangleType();
-      if (!second) return nullptr;
-      auto reqt = Factory.createNode(
-          Node::Kind::DependentGenericSameTypeRequirement);
-      reqt->addChild(constrainedType, Factory);
-      reqt->addChild(second, Factory);
-      return reqt;
-    }
-
-    if (Mangled.nextIf('l')) {
-      StringRef name;
-      Node::Kind kind;
-      Node::IndexType size = SIZE_MAX;
-      Node::IndexType alignment = SIZE_MAX;
-      if (Mangled.nextIf('U')) {
-        kind = Node::Kind::Identifier;
-        name = "U";
-      } else if (Mangled.nextIf('R')) {
-        kind = Node::Kind::Identifier;
-        name = "R";
-      } else if (Mangled.nextIf('N')) {
-        kind = Node::Kind::Identifier;
-        name = "N";
-      } else if (Mangled.nextIf('T')) {
-        kind = Node::Kind::Identifier;
-        name = "T";
-      } else if (Mangled.nextIf('E')) {
-        kind = Node::Kind::Identifier;
-        if (!demangleNatural(size))
-          return nullptr;
-        if (!Mangled.nextIf('_'))
-          return nullptr;
-        if (!demangleNatural(alignment))
-          return nullptr;
-        name = "E";
-      } else if (Mangled.nextIf('e')) {
-        kind = Node::Kind::Identifier;
-        if (!demangleNatural(size))
-          return nullptr;
-        name = "e";
-      } else if (Mangled.nextIf('M')) {
-        kind = Node::Kind::Identifier;
-        if (!demangleNatural(size))
-          return nullptr;
-        if (!Mangled.nextIf('_'))
-          return nullptr;
-        if (!demangleNatural(alignment))
-          return nullptr;
-        name = "M";
-      } else if (Mangled.nextIf('m')) {
-        kind = Node::Kind::Identifier;
-        if (!demangleNatural(size))
-          return nullptr;
-        name = "m";
-      } else {
-        return nullptr;
-      }
-
-      NodePointer second = Factory.createNode(kind, name);
-      if (!second) return nullptr;
-      auto reqt = Factory.createNode(
-        Node::Kind::DependentGenericLayoutRequirement);
-      reqt->addChild(constrainedType, Factory);
-      reqt->addChild(second, Factory);
-      if (size != SIZE_MAX) {
-        reqt->addChild(Factory.createNode(Node::Kind::Number, size), Factory);
-        if (alignment != SIZE_MAX)
-          reqt->addChild(Factory.createNode(Node::Kind::Number, alignment), Factory);
-      }
-      return reqt;
-    }
-
-    // Base class constraints are introduced by a class type mangling, which
-    // will begin with either 'C' or 'S'.
-    if (!Mangled)
-      return nullptr;
-    NodePointer constraint = nullptr;
-
-    auto next = Mangled.peek();
-
-    if (next == 'C') {
-      constraint = demangleType();
-      if (!constraint) return nullptr;
-    } else if (next == 'S') {
-      // A substitution may be either the module name of a protocol or a full
-      // type name.
-      NodePointer typeName = nullptr;
-      Mangled.next();
-      NodePointer sub = demangleSubstitutionIndex();
-      if (!sub) return nullptr;
-      if (sub->getKind() == Node::Kind::Protocol
-          || sub->getKind() == Node::Kind::Class) {
-        typeName = sub;
-      } else if (sub->getKind() == Node::Kind::Module) {
-        typeName = demangleProtocolNameGivenContext(sub);
-        if (!typeName)
-          return nullptr;
-      } else {
-        return nullptr;
-      }
-      constraint = Factory.createNode(Node::Kind::Type);
-      constraint->addChild(typeName, Factory);
-    } else {
-      constraint = demangleProtocolName();
-      if (!constraint)
-        return nullptr;
-    }
-    auto reqt = Factory.createNode(
-                          Node::Kind::DependentGenericConformanceRequirement);
-    reqt->addChild(constrainedType, Factory);
-    reqt->addChild(constraint, Factory);
-    return reqt;
-  }
-  
-  NodePointer demangleArchetypeType() {
-    auto makeAssociatedType = [&](NodePointer root) -> NodePointer {
-      NodePointer name = demangleIdentifier();
-      if (!name) return nullptr;
-      auto assocType = Factory.createNode(Node::Kind::AssociatedTypeRef);
-      assocType->addChild(root, Factory);
-      assocType->addChild(name, Factory);
-      Substitutions.push_back(assocType);
-      return assocType;
-    };
-    
-    if (Mangled.nextIf('Q')) {
-      NodePointer root = demangleArchetypeType();
-      if (!root) return nullptr;
-      return makeAssociatedType(root);
-    }
-    if (Mangled.nextIf('S')) {
-      NodePointer sub = demangleSubstitutionIndex();
-      if (!sub) return nullptr;
-      return makeAssociatedType(sub);
-    }
-    if (Mangled.nextIf('s')) {
-      NodePointer stdlib = Factory.createNode(Node::Kind::Module, STDLIB_NAME);
-      return makeAssociatedType(stdlib);
-    }
-    return nullptr;
-  }
-
-  NodePointer demangleTuple(IsVariadic isV) {
-    NodePointer tuple = Factory.createNode(Node::Kind::Tuple);
-    NodePointer elt = nullptr;
-    while (!Mangled.nextIf('_')) {
-      if (!Mangled)
-        return nullptr;
-      elt = Factory.createNode(Node::Kind::TupleElement);
-
-      if (isStartOfIdentifier(Mangled.peek())) {
-        NodePointer label = demangleIdentifier(Node::Kind::TupleElementName);
-        if (!label)
-          return nullptr;
-        elt->addChild(label, Factory);
-      }
-
-      NodePointer type = demangleType();
-      if (!type)
-        return nullptr;
-      elt->addChild(type, Factory);
-
-      tuple->addChild(elt, Factory);
-    }
-    if (isV == IsVariadic::yes && elt) {
-      elt->reverseChildren();
-      NodePointer marker = Factory.createNode(Node::Kind::VariadicMarker);
-      elt->addChild(marker, Factory);
-      elt->reverseChildren();
-    }
-    return tuple;
-  }
-  
-  NodePointer postProcessReturnTypeNode (NodePointer out_args) {
-    NodePointer out_node = Factory.createNode(Node::Kind::ReturnType);
-    out_node->addChild(out_args, Factory);
-    return out_node;
-  }
-
-  NodePointer demangleType() {
-    NodePointer type = demangleTypeImpl();
-    if (!type)
-      return nullptr;
-    NodePointer nodeType = Factory.createNode(Node::Kind::Type);
-    nodeType->addChild(type, Factory);
-    return nodeType;
-  }
-  
-  NodePointer demangleFunctionType(Node::Kind kind) {
-    bool throws = false, concurrent = false, async = false;
-    auto diffKind = MangledDifferentiabilityKind::NonDifferentiable;
-    NodePointer globalActorType = nullptr;
-    if (Mangled) {
-      throws = Mangled.nextIf('z');
-      concurrent = Mangled.nextIf('y');
-      async = Mangled.nextIf('Z');
-      if (Mangled.nextIf('D')) {
-        switch (auto kind = (MangledDifferentiabilityKind)Mangled.next()) {
-        case MangledDifferentiabilityKind::Forward:
-        case MangledDifferentiabilityKind::Reverse:
-        case MangledDifferentiabilityKind::Normal:
-        case MangledDifferentiabilityKind::Linear:
-          diffKind = kind;
-          break;
-        case MangledDifferentiabilityKind::NonDifferentiable:
-          assert(false && "Impossible case 'NonDifferentiable'");
-        }
-      }
-      if (Mangled.nextIf('Y')) {
-        globalActorType = demangleType();
-        if (!globalActorType)
-          return nullptr;
-      }
-    }
-    NodePointer in_args = demangleType();
-    if (!in_args)
-      return nullptr;
-    NodePointer out_args = demangleType();
-    if (!out_args)
-      return nullptr;
-    NodePointer block = Factory.createNode(kind);
-    
-    if (throws) {
-      block->addChild(Factory.createNode(Node::Kind::ThrowsAnnotation), Factory);
-    }
-    if (async) {
-      block->addChild(Factory.createNode(Node::Kind::AsyncAnnotation), Factory);
-    }
-    if (concurrent) {
-      block->addChild(
-          Factory.createNode(Node::Kind::ConcurrentFunctionType), Factory);
-    }
-    if (diffKind != MangledDifferentiabilityKind::NonDifferentiable) {
-      block->addChild(
-          Factory.createNode(
-              Node::Kind::DifferentiableFunctionType, (char)diffKind), Factory);
-    }
-    if (globalActorType) {
-      auto globalActorNode =
-          Factory.createNode(Node::Kind::GlobalActorFunctionType);
-      globalActorNode->addChild(globalActorType, Factory);
-      block->addChild(globalActorNode, Factory);
-    }
-
-    NodePointer in_node = Factory.createNode(Node::Kind::ArgumentTuple);
-    block->addChild(in_node, Factory);
-    in_node->addChild(in_args, Factory);
-    block->addChild(postProcessReturnTypeNode(out_args), Factory);
-    return block;
-  }
-  
-  NodePointer demangleTypeImpl() {
-    if (!Mangled)
-      return nullptr;
-    char c = Mangled.next();
-    if (c == 'B') {
-      if (!Mangled)
-        return nullptr;
-      c = Mangled.next();
-      if (c == 'b')
-        return Factory.createNode(Node::Kind::BuiltinTypeName,
-                                     "Builtin.BridgeObject");
-      if (c == 'B')
-        return Factory.createNode(Node::Kind::BuiltinTypeName,
-                                     "Builtin.UnsafeValueBuffer");
-      if (c == 'f') {
-        Node::IndexType size;
-        if (demangleBuiltinSize(size)) {
-          return Factory.createNode(
-              Node::Kind::BuiltinTypeName,
-              std::move(DemanglerPrinter() << "Builtin.FPIEEE" << size).str());
-        }
-      }
-      if (c == 'i') {
-        Node::IndexType size;
-        if (demangleBuiltinSize(size)) {
-          return Factory.createNode(
-              Node::Kind::BuiltinTypeName,
-              (DemanglerPrinter() << "Builtin.Int" << size).str());
-        }
-      }
-      if (c == 'v') {
-        Node::IndexType elts;
-        if (demangleNatural(elts)) {
-          if (!Mangled.nextIf('B'))
-            return nullptr;
-          if (Mangled.nextIf('i')) {
-            Node::IndexType size;
-            if (!demangleBuiltinSize(size))
-              return nullptr;
-            return Factory.createNode(
-                Node::Kind::BuiltinTypeName,
-                (DemanglerPrinter() << "Builtin.Vec" << elts << "xInt" << size)
-                    .str());
-          }
-          if (Mangled.nextIf('f')) {
-            Node::IndexType size;
-            if (!demangleBuiltinSize(size))
-              return nullptr;
-            return Factory.createNode(
-                Node::Kind::BuiltinTypeName,
-                (DemanglerPrinter() << "Builtin.Vec" << elts << "xFloat"
-                                    << size).str());
-          }
-          if (Mangled.nextIf('p'))
-            return Factory.createNode(
-                Node::Kind::BuiltinTypeName,
-                (DemanglerPrinter() << "Builtin.Vec" << elts << "xRawPointer")
-                    .str());
-        }
-      }
-      if (c == 'O')
-        return Factory.createNode(Node::Kind::BuiltinTypeName,
-                                     "Builtin.UnknownObject");
-      if (c == 'o')
-        return Factory.createNode(Node::Kind::BuiltinTypeName,
-                                     "Builtin.NativeObject");
-      if (c == 'p')
-        return Factory.createNode(Node::Kind::BuiltinTypeName,
-                                     "Builtin.RawPointer");
-      if (c == 't')
-        return Factory.createNode(Node::Kind::BuiltinTypeName,
-                                     "Builtin.SILToken");
-      if (c == 'w')
-        return Factory.createNode(Node::Kind::BuiltinTypeName,
-                                     "Builtin.Word");
-      return nullptr;
-    }
-    if (c == 'a')
-      return demangleDeclarationName(Node::Kind::TypeAlias);
-
-    if (c == 'b') {
-      return demangleFunctionType(Node::Kind::ObjCBlock);
-    }
-    if (c == 'c') {
-      return demangleFunctionType(Node::Kind::CFunctionPointer);
-    }
-    if (c == 'D') {
-      NodePointer type = demangleType();
-      if (!type)
-        return nullptr;
-
-      NodePointer dynamicSelf = Factory.createNode(Node::Kind::DynamicSelf);
-      dynamicSelf->addChild(type, Factory);
-      return dynamicSelf;
-    }
-    if (c == 'E') {
-      if (!Mangled.nextIf('R'))
-        return nullptr;
-      if (!Mangled.nextIf('R'))
-        return nullptr;
-      return Factory.createNode(Node::Kind::ErrorType, std::string());
-    }
-    if (c == 'F') {
-      return demangleFunctionType(Node::Kind::FunctionType);
-    }
-    if (c == 'f') {
-      return demangleFunctionType(Node::Kind::UncurriedFunctionType);
-    }
-    if (c == 'G') {
-      return demangleBoundGenericType();
-    }
-    if (c == 'X') {
-      if (Mangled.nextIf('b')) {
-        NodePointer type = demangleType();
-        if (!type)
-          return nullptr;
-        NodePointer boxType = Factory.createNode(Node::Kind::SILBoxType);
-        boxType->addChild(type, Factory);
-        return boxType;
-      }
-      if (Mangled.nextIf('B')) {
-        NodePointer signature = nullptr;
-        if (Mangled.nextIf('G')) {
-          signature = demangleGenericSignature(/*pseudogeneric*/ false);
-          if (!signature)
-            return nullptr;
-        }
-        NodePointer layout = Factory.createNode(Node::Kind::SILBoxLayout);
-        while (!Mangled.nextIf('_')) {
-          Node::Kind kind;
-          if (Mangled.nextIf('m'))
-            kind = Node::Kind::SILBoxMutableField;
-          else if (Mangled.nextIf('i'))
-            kind = Node::Kind::SILBoxImmutableField;
-          else
-            return nullptr;
-          
-          auto type = demangleType();
-          if (!type)
-            return nullptr;
-          auto field = Factory.createNode(kind);
-          field->addChild(type, Factory);
-          layout->addChild(field, Factory);
-        }
-        NodePointer genericArgs = nullptr;
-        if (signature) {
-          genericArgs = Factory.createNode(Node::Kind::TypeList);
-          while (!Mangled.nextIf('_')) {
-            auto type = demangleType();
-            if (!type)
-              return nullptr;
-            genericArgs->addChild(type, Factory);
-          }
-        }
-        NodePointer boxType =
-          Factory.createNode(Node::Kind::SILBoxTypeWithLayout);
-        boxType->addChild(layout, Factory);
-        if (signature) {
-          boxType->addChild(signature, Factory);
-          assert(genericArgs);
-          boxType->addChild(genericArgs, Factory);
-        }
-        return boxType;
-      }
-    }
-    if (c == 'K') {
-      return demangleFunctionType(Node::Kind::AutoClosureType);
-    }
-    if (c == 'M') {
-      NodePointer type = demangleType();
-      if (!type)
-        return nullptr;
-      NodePointer metatype = Factory.createNode(Node::Kind::Metatype);
-      metatype->addChild(type, Factory);
-      return metatype;
-    }
-    if (c == 'X') {
-      if (Mangled.nextIf('M')) {
-        NodePointer metatypeRepr = demangleMetatypeRepresentation();
-        if (!metatypeRepr) return nullptr;
-
-        NodePointer type = demangleType();
-        if (!type)
-          return nullptr;
-        NodePointer metatype = Factory.createNode(Node::Kind::Metatype);
-        metatype->addChild(metatypeRepr, Factory);
-        metatype->addChild(type, Factory);
-        return metatype;
-      }
-    }
-    if (c == 'P') {
-      if (Mangled.nextIf('M')) {
-        NodePointer type = demangleType();
-        if (!type) return nullptr;
-        auto metatype = Factory.createNode(Node::Kind::ExistentialMetatype);
-        metatype->addChild(type, Factory);
-        return metatype;
-      }
-
-      return demangleProtocolList();
-    }
-
-    if (c == 'X') {
-      if (Mangled.nextIf('P')) {
-        if (Mangled.nextIf('M')) {
-          NodePointer metatypeRepr = demangleMetatypeRepresentation();
-          if (!metatypeRepr) return nullptr;
-
-          NodePointer type = demangleType();
-          if (!type) return nullptr;
-
-          auto metatype = Factory.createNode(Node::Kind::ExistentialMetatype);
-          metatype->addChild(metatypeRepr, Factory);
-          metatype->addChild(type, Factory);
-          return metatype;
-        }
-
-        return demangleProtocolList();
-      }
-    }
-    if (c == 'Q') {
-      if (Mangled.nextIf('u')) {
-        // Special mangling for opaque return type.
-        return Factory.createNode(Node::Kind::OpaqueReturnType);
-      }
-      return demangleArchetypeType();
-    }
-    if (c == 'q') {
-      return demangleDependentType();
-    }
-    if (c == 'x') {
-      // Special mangling for the first generic param.
-      return getDependentGenericParamType(0, 0);
-    }
-    if (c == 'w') {
-      return demangleAssociatedTypeSimple();
-    }
-    if (c == 'W') {
-      return demangleAssociatedTypeCompound();
-    }
-    if (c == 'R') {
-      NodePointer inout = Factory.createNode(Node::Kind::InOut);
-      NodePointer type = demangleTypeImpl();
-      if (!type)
-        return nullptr;
-      inout->addChild(type, Factory);
-      return inout;
-    }
-    if (c == 'k') {
-      auto noDerivative = Factory.createNode(Node::Kind::NoDerivative);
-      auto type = demangleTypeImpl();
-      if (!type)
-        return nullptr;
-      noDerivative->addChild(type, Factory);
-      return noDerivative;
-    }
-    if (c == 'S') {
-      return demangleSubstitutionIndex();
-    }
-    if (c == 'T') {
-      return demangleTuple(IsVariadic::no);
-    }
-    if (c == 't') {
-      return demangleTuple(IsVariadic::yes);
-    }
-    if (c == 'u') {
-      NodePointer sig = demangleGenericSignature();
-      if (!sig) return nullptr;
-      NodePointer sub = demangleType();
-      if (!sub) return nullptr;
-      NodePointer dependentGenericType
-        = Factory.createNode(Node::Kind::DependentGenericType);
-      dependentGenericType->addChild(sig, Factory);
-      dependentGenericType->addChild(sub, Factory);
-      return dependentGenericType;
-    }
-    if (c == 'X') {
-      if (Mangled.nextIf('f')) {
-        return demangleFunctionType(Node::Kind::ThinFunctionType);
-      }
-      if (Mangled.nextIf('o')) {
-        NodePointer type = demangleType();
-        if (!type)
-          return nullptr;
-        NodePointer unowned = Factory.createNode(Node::Kind::Unowned);
-        unowned->addChild(type, Factory);
-        return unowned;
-      }
-      if (Mangled.nextIf('u')) {
-        NodePointer type = demangleType();
-        if (!type)
-          return nullptr;
-        NodePointer unowned = Factory.createNode(Node::Kind::Unmanaged);
-        unowned->addChild(type, Factory);
-        return unowned;
-      }
-      if (Mangled.nextIf('w')) {
-        NodePointer type = demangleType();
-        if (!type)
-          return nullptr;
-        NodePointer weak = Factory.createNode(Node::Kind::Weak);
-        weak->addChild(type, Factory);
-        return weak;
-      }
-
-      // type ::= 'XF' impl-function-type
-      if (Mangled.nextIf('F')) {
-        return demangleImplFunctionType();
-      }
-
-      return nullptr;
-    }
-    if (isStartOfNominalType(c))
-      return demangleDeclarationName(nominalTypeMarkerToNodeKind(c));
-    return nullptr;
-  }
-
-  bool demangleReabstractSignature(NodePointer signature) {
-    if (Mangled.nextIf('G')) {
-      NodePointer generics = demangleGenericSignature();
-      if (!generics) return false;
-      signature->addChild(generics, Factory);
-    }
-
-    NodePointer srcType = demangleType();
-    if (!srcType) return false;
-    signature->addChild(srcType, Factory);
-
-    NodePointer destType = demangleType();
-    if (!destType) return false;
-    signature->addChild(destType, Factory);
-
-    return true;
-  }
-
-  // impl-function-type ::= impl-callee-convention impl-function-attribute*
-  //                        generics? '_' impl-parameter* '_' impl-result* '_'
-  // impl-function-attribute ::= 'Cb'            // compatible with C block invocation function
-  // impl-function-attribute ::= 'Cc'            // compatible with C global function
-  // impl-function-attribute ::= 'Cm'            // compatible with Swift method
-  // impl-function-attribute ::= 'CO'            // compatible with ObjC method
-  // impl-function-attribute ::= 'Cw'            // compatible with protocol witness
-  // impl-function-attribute ::= 'G'             // generic
-  NodePointer demangleImplFunctionType() {
-    NodePointer type = Factory.createNode(Node::Kind::ImplFunctionType);
-
-    if (!demangleImplCalleeConvention(type))
-      return nullptr;
-
-    if (Mangled.nextIf('C')) {
-      if (Mangled.nextIf('b'))
-        addImplFunctionConvention(type, "block");
-      else if (Mangled.nextIf('c'))
-        addImplFunctionConvention(type, "c");
-      else if (Mangled.nextIf('m'))
-        addImplFunctionConvention(type, "method");
-      else if (Mangled.nextIf('O'))
-        addImplFunctionConvention(type, "objc_method");
-      else if (Mangled.nextIf('w'))
-        addImplFunctionConvention(type, "witness_method");
-      else
-        return nullptr;
-    }
-
-    if (Mangled.nextIf('h'))
-      addImplFunctionAttribute(type, "@Sendable");
-
-    if (Mangled.nextIf('H'))
-      addImplFunctionAttribute(type, "@async");
-
-    // Enter a new generic context if this type is generic.
-    // FIXME: replace with std::optional, when we have it.
-    bool isPseudogeneric = false;
-    if (Mangled.nextIf('G') ||
-        (isPseudogeneric = Mangled.nextIf('g'))) {
-      NodePointer generics = demangleGenericSignature(isPseudogeneric);
-      if (!generics)
-        return nullptr;
-      type->addChild(generics, Factory);
-    }
-
-    // Expect the attribute terminator.
-    if (!Mangled.nextIf('_'))
-      return nullptr;
-
-    // Demangle the parameters.
-    if (!demangleImplParameters(type))
-      return nullptr;
-
-    // Demangle the result type.
-    if (!demangleImplResults(type))
-      return nullptr;
-
-    return type;
-  }
-
-  enum class ImplConventionContext { Callee, Parameter, Result };
-
-  /// impl-convention ::= 'a'                     // direct, autoreleased
-  /// impl-convention ::= 'd'                     // direct, no ownership transfer
-  /// impl-convention ::= 'D'                     // direct, no ownership transfer,
-  ///                                             // dependent on self
-  /// impl-convention ::= 'g'                     // direct, guaranteed
-  /// impl-convention ::= 'e'                     // direct, deallocating
-  /// impl-convention ::= 'i'                     // indirect, ownership transfer
-  /// impl-convention ::= 'l'                     // indirect, inout
-  /// impl-convention ::= 'o'                     // direct, ownership transfer
-  ///
-  /// Returns an empty string otherwise.
-  StringRef demangleImplConvention(ImplConventionContext ctxt) {
-#define CASE(CHAR, FOR_CALLEE, FOR_PARAMETER, FOR_RESULT)            \
-    if (Mangled.nextIf(CHAR)) {                                      \
-      switch (ctxt) {                                                \
-      case ImplConventionContext::Callee: return (FOR_CALLEE);       \
-      case ImplConventionContext::Parameter: return (FOR_PARAMETER); \
-      case ImplConventionContext::Result: return (FOR_RESULT);       \
-      }                                                              \
-      return StringRef();                                            \
-    }
-    auto Nothing = StringRef();
-    CASE('a',   Nothing,                Nothing,         "@autoreleased")
-    CASE('d',   "@callee_unowned",      "@unowned",      "@unowned")
-    CASE('D',   Nothing,                Nothing,         "@unowned_inner_pointer")
-    CASE('g',   "@callee_guaranteed",   "@guaranteed",   Nothing)
-    CASE('e',   Nothing,                "@deallocating", Nothing)
-    CASE('i',   Nothing,                "@in",           "@out")
-    CASE('l',   Nothing,                "@inout",        Nothing)
-    CASE('o',   "@callee_owned",        "@owned",        "@owned")
-    return Nothing;
-#undef CASE
-  }
-
-  // impl-callee-convention ::= 't'
-  // impl-callee-convention ::= impl-convention
-  bool demangleImplCalleeConvention(NodePointer type) {
-    StringRef attr;
-    if (Mangled.nextIf('t')) {
-      attr = "@convention(thin)";
-    } else {
-      attr = demangleImplConvention(ImplConventionContext::Callee);
-    }
-    if (attr.empty()) {
-      return false;
-    }
-    type->addChild(Factory.createNode(Node::Kind::ImplConvention, attr), Factory);
-    return true;
-  }
-
-  void addImplFunctionAttribute(NodePointer parent, StringRef attr,
-                         Node::Kind kind = Node::Kind::ImplFunctionAttribute) {
-    parent->addChild(Factory.createNode(kind, attr), Factory);
-  }
-
-  void addImplFunctionConvention(NodePointer parent, StringRef attr) {
-    auto attrNode = Factory.createNode(Node::Kind::ImplFunctionConvention);
-    attrNode->addChild(
-        Factory.createNode(Node::Kind::ImplFunctionConventionName, attr),
-        Factory);
-    parent->addChild(attrNode, Factory);
-  }
-
-  // impl-parameter ::= impl-convention type
-  bool demangleImplParameters(NodePointer parent) {
-    while (!Mangled.nextIf('_')) {
-      auto input = demangleImplParameterOrResult(Node::Kind::ImplParameter);
-      if (!input) return false;
-      parent->addChild(input, Factory);
-    }
-    return true;
-  }
-
-  // impl-result ::= impl-convention type
-  bool demangleImplResults(NodePointer parent) {
-    while (!Mangled.nextIf('_')) {
-      auto res = demangleImplParameterOrResult(Node::Kind::ImplResult);
-      if (!res) return false;
-      parent->addChild(res, Factory);
-    }
-    return true;
-  }
-
-  NodePointer demangleImplParameterOrResult(Node::Kind kind) {
-    if (Mangled.nextIf('z')) {
-      // Only valid for a result.
-      if (kind != Node::Kind::ImplResult)
-        return nullptr;
-      kind = Node::Kind::ImplErrorResult;
-    }
-
-    ImplConventionContext ConvCtx;
-    if (kind == Node::Kind::ImplParameter) {
-      ConvCtx = ImplConventionContext::Parameter;
-    } else if (kind == Node::Kind::ImplResult
-               || kind == Node::Kind::ImplErrorResult) {
-      ConvCtx = ImplConventionContext::Result;
-    } else {
-      return nullptr;
-    }
-
-    auto convention = demangleImplConvention(ConvCtx);
-    if (convention.empty()) return nullptr;
-    auto type = demangleType();
-    if (!type) return nullptr;
-
-    NodePointer node = Factory.createNode(kind);
-    node->addChild(Factory.createNode(Node::Kind::ImplConvention, convention),
-                   Factory);
-    node->addChild(type, Factory);
-    
-    return node;
-  }
-};
-} // end anonymous namespace
-
-NodePointer
-swift::Demangle::demangleOldSymbolAsNode(StringRef MangledName,
-                                         NodeFactory &Factory) {
-  OldDemangler demangler(MangledName, Factory);
-  return demangler.demangleTopLevel();
-}
-
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/OldRemangler.cpp b/symbolic-demangle/vendor/swift/lib/Demangling/OldRemangler.cpp
deleted file mode 100644
index afc882a5d..000000000
--- a/symbolic-demangle/vendor/swift/lib/Demangling/OldRemangler.cpp
+++ /dev/null
@@ -1,2284 +0,0 @@
-//===--- OldRemangler.cpp - Old Swift Re-mangler --------------------------===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file implements the remangler, which turns a demangling parse
-//  tree back into a mangled string.  This is useful for tools which
-//  want to extract subtrees from mangled strings.
-//
-//===----------------------------------------------------------------------===//
-
-#include "swift/Demangling/Demangler.h"
-#include "swift/Demangling/Punycode.h"
-#include "swift/Demangling/ManglingUtils.h"
-#include "swift/AST/Ownership.h"
-#include "swift/Strings.h"
-#include "RemanglerBase.h"
-#include <cstdio>
-#include <cstdlib>
-
-using namespace swift;
-using namespace Demangle;
-
-[[noreturn]]
-static void unreachable(const char *Message) {
-  fprintf(stderr, "fatal error: %s\n", Message);
-  std::abort();
-}
-
-namespace {
-  class Remangler : public RemanglerBase {
-  public:
-    Remangler(NodeFactory &Factory) : RemanglerBase(Factory) { }
-
-    class EntityContext {
-      bool AsContext = false;
-      std::string AnonymousContextDiscriminator;
-    public:
-      bool isAsContext() const {
-        return AsContext;
-      }
-      
-      void setAnonymousContextDiscriminator(StringRef discriminator) {
-        AnonymousContextDiscriminator = discriminator.str();
-      }
-      
-      std::string takeAnonymousContextDiscriminator() {
-        auto r = std::move(AnonymousContextDiscriminator);
-        AnonymousContextDiscriminator.clear();
-        return r;
-      }
-
-      class ManglingContextRAII {
-        EntityContext &Ctx;
-        bool SavedValue;
-      public:
-        ManglingContextRAII(EntityContext &ctx)
-          : Ctx(ctx), SavedValue(ctx.AsContext) {
-          ctx.AsContext = true;
-        }
-
-        ~ManglingContextRAII() {
-          Ctx.AsContext = SavedValue;
-        }
-      };
-    };
-
-    void mangle(Node *node) {
-      switch (node->getKind()) {
-#define NODE(ID) case Node::Kind::ID: return mangle##ID(node);
-#include "swift/Demangling/DemangleNodes.def"
-      }
-      unreachable("bad demangling tree node");
-    }
-
-    void mangleGenericArgs(Node *node, EntityContext &ctx);
-    void mangleAnyNominalType(Node *node, EntityContext &ctx);
-
-#define NODE(ID)                                                        \
-    void mangle##ID(Node *node);
-#define CONTEXT_NODE(ID)                                                \
-    void mangle##ID(Node *node);                                        \
-    void mangle##ID(Node *node, EntityContext &ctx);
-#include "swift/Demangling/DemangleNodes.def"
-
-    void mangleIndex(Node::IndexType index);
-    void mangleIdentifier(StringRef name, OperatorKind operatorKind);
-    void mangleAccessor(Node *storageNode, StringRef accessorCode,
-                        EntityContext &ctx);
-
-    void mangleChildNodes(Node *node) { mangleNodes(node->begin(), node->end()); }
-    void mangleNodes(Node::iterator i, Node::iterator e) {
-      for (; i != e; ++i) {
-        mangle(*i);
-      }
-    }
-    void mangleSingleChildNode(Node *node) {
-      assert(node->getNumChildren() == 1);
-      mangle(*node->begin());
-    }
-    void mangleChildNode(Node *node, unsigned index) {
-      assert(index < node->getNumChildren());
-      mangle(node->begin()[index]);
-    }
-
-    void mangleSimpleEntity(Node *node, char basicKind, StringRef entityKind,
-                            EntityContext &ctx);
-    void mangleNamedEntity(Node *node, char basicKind, StringRef entityKind,
-                          EntityContext &ctx,
-                          StringRef ArtificialPrivateDiscriminator = {});
-    void mangleTypedEntity(Node *node, char basicKind, StringRef entityKind,
-                           EntityContext &ctx);
-    void mangleNamedAndTypedEntity(Node *node, char basicKind,
-                                   StringRef entityKind,
-                                   EntityContext &ctx);
-    void mangleNominalType(Node *node, char basicKind, EntityContext &ctx,
-                          StringRef ArtificialPrivateDiscriminator = {});
-
-    void mangleProtocolWithoutPrefix(Node *node);
-    void mangleProtocolListWithoutPrefix(Node *node,
-                                         Node *additionalProto = nullptr);
-
-    void mangleEntityContext(Node *node, EntityContext &ctx);
-    void mangleEntityType(Node *node, EntityContext &ctx);
-    void mangleEntityGenericType(Node *node, EntityContext &ctx);
-
-    bool trySubstitution(Node *node, SubstitutionEntry &entry);
-    bool mangleStandardSubstitution(Node *node);
-
-    void mangleDependentGenericParamIndex(Node *node);
-    void mangleConstrainedType(Node *node);
-  };
-} // end anonymous namespace
-
-#define NODE(ID)
-#define CONTEXT_NODE(ID)                        \
-void Remangler::mangle##ID(Node *node) {        \
-  EntityContext ctx;                            \
-  mangle##ID(node, ctx);                        \
-}
-#include "swift/Demangling/DemangleNodes.def"
-
-/// Re-apply labels from the function to its parameter type
-/// to preserve old mangling style.
-///
-/// \param LabelList The list of labels to apply.
-/// \param OrigType  The function parameter type to apply labels to.
-/// \param Factory   The node factory to use to allocate new nodes.
-static NodePointer applyParamLabels(NodePointer LabelList, NodePointer OrigType,
-                                    NodeFactory &Factory) {
-  if (LabelList->getNumChildren() == 0)
-    return OrigType;
-
-  auto applyParamLabels = [&](NodePointer ArgTuple) -> NodePointer {
-    assert(ArgTuple->getKind() == Node::Kind::ArgumentTuple);
-
-    auto ParamsType = Factory.createNode(Node::Kind::ArgumentTuple);
-    auto Tuple = Factory.createNode(Node::Kind::Tuple);
-
-    auto OrigTuple = ArgTuple->getFirstChild()->getFirstChild();
-    assert(OrigTuple->getKind() == Node::Kind::Tuple);
-
-    for (unsigned i = 0, n = OrigTuple->getNumChildren(); i != n; ++i) {
-      const auto Label = LabelList->getChild(i);
-      if (Label->getKind() == Node::Kind::FirstElementMarker) {
-        Tuple->addChild(OrigTuple->getChild(i), Factory);
-        continue;
-      }
-
-      auto OrigElt = OrigTuple->getChild(i);
-      auto NewElt = Factory.createNode(Node::Kind::TupleElement);
-
-      NewElt->addChild(Factory.createNodeWithAllocatedText(
-                           Node::Kind::TupleElementName, Label->getText()),
-                       Factory);
-
-      for (auto &Child : *OrigElt)
-        NewElt->addChild(Child, Factory);
-
-      Tuple->addChild(NewElt, Factory);
-    }
-
-    auto Type = Factory.createNode(Node::Kind::Type);
-    Type->addChild(Tuple, Factory);
-    ParamsType->addChild(Type, Factory);
-    return ParamsType;
-  };
-
-  auto visitTypeChild = [&](NodePointer Child) -> NodePointer {
-    if (Child->getKind() != Node::Kind::FunctionType &&
-        Child->getKind() != Node::Kind::NoEscapeFunctionType)
-      return Child;
-
-    auto FuncType = Factory.createNode(Node::Kind::FunctionType);
-    for (unsigned i = 0, n = Child->getNumChildren(); i != n; ++i) {
-      NodePointer FuncChild = Child->getChild(i);
-      if (FuncChild->getKind() == Node::Kind::ArgumentTuple)
-        FuncChild = applyParamLabels(FuncChild);
-      FuncType->addChild(FuncChild, Factory);
-    }
-    return FuncType;
-  };
-
-  auto Type = Factory.createNode(OrigType->getKind());
-  for (auto &Child : *OrigType)
-    Type->addChild(visitTypeChild(Child), Factory);
-
-  return Type;
-}
-
-bool Remangler::trySubstitution(Node *node, SubstitutionEntry &entry) {
-  if (mangleStandardSubstitution(node))
-    return true;
-
-  // Go ahead and initialize the substitution entry.
-  entry.setNode(node, /*treatAsIdentifier=*/ false);
-
-  int Idx = findSubstitution(entry);
-  if (Idx < 0)
-    return false;
-
-  Buffer << 'S';
-  mangleIndex(Idx);
-  return true;
-}
-
-static bool isInSwiftModule(Node *node) {
-  Node *context = node->getFirstChild();
-  return (context->getKind() == Node::Kind::Module &&
-          context->getText() == STDLIB_NAME &&
-          // Check for private declarations in Swift
-          node->getChild(1)->getKind() == Node::Kind::Identifier);
-};
-
-bool Remangler::mangleStandardSubstitution(Node *node) {
-  // Look for known substitutions.
-  switch (node->getKind()) {
-#define SUCCESS_IF_IS(VALUE, EXPECTED, SUBSTITUTION)            \
-    do {                                                        \
-      if ((VALUE) == (EXPECTED)) {                              \
-        Buffer << SUBSTITUTION;                                    \
-        return true;                                            \
-      }                                                         \
-    } while (0)
-#define SUCCESS_IF_TEXT_IS(EXPECTED, SUBSTITUTION)              \
-    SUCCESS_IF_IS(node->getText(), EXPECTED, SUBSTITUTION)
-#define SUCCESS_IF_DECLNAME_IS(EXPECTED, SUBSTITUTION)          \
-    SUCCESS_IF_IS(node->getChild(1)->getText(), EXPECTED, SUBSTITUTION)
-
-    case Node::Kind::Module:
-      SUCCESS_IF_TEXT_IS(STDLIB_NAME, "s");
-      SUCCESS_IF_TEXT_IS(MANGLING_MODULE_OBJC, "So");
-      SUCCESS_IF_TEXT_IS(MANGLING_MODULE_CLANG_IMPORTER, "SC");
-      break;
-    case Node::Kind::Structure:
-      if (isInSwiftModule(node)) {
-        SUCCESS_IF_DECLNAME_IS("Array", "Sa");
-        SUCCESS_IF_DECLNAME_IS("Bool", "Sb");
-        SUCCESS_IF_DECLNAME_IS("UnicodeScalar", "Sc");
-        SUCCESS_IF_DECLNAME_IS("Double", "Sd");
-        SUCCESS_IF_DECLNAME_IS("Float", "Sf");
-        SUCCESS_IF_DECLNAME_IS("Int", "Si");
-        SUCCESS_IF_DECLNAME_IS("UnsafeRawPointer", "SV");
-        SUCCESS_IF_DECLNAME_IS("UnsafeMutableRawPointer", "Sv");
-        SUCCESS_IF_DECLNAME_IS("UnsafePointer", "SP");
-        SUCCESS_IF_DECLNAME_IS("UnsafeMutablePointer", "Sp");
-        SUCCESS_IF_DECLNAME_IS("UnsafeBufferPointer", "SR");
-        SUCCESS_IF_DECLNAME_IS("UnsafeMutableBufferPointer", "Sr");
-        SUCCESS_IF_DECLNAME_IS("String", "SS");
-        SUCCESS_IF_DECLNAME_IS("UInt", "Su");
-      }
-      break;
-    case Node::Kind::Enum:
-      if (isInSwiftModule(node)) {
-        SUCCESS_IF_DECLNAME_IS("Optional", "Sq");
-        SUCCESS_IF_DECLNAME_IS("ImplicitlyUnwrappedOptional", "SQ");
-      }
-      break;
-
-    default:
-      break;
-
-#undef SUCCESS_IF_DECLNAME_IS
-#undef SUCCESS_IF_TEXT_IS
-#undef SUCCESS_IF_IS
-  }
-  return false;
-}
-
-void Remangler::mangleIdentifier(Node *node) {
-  mangleIdentifier(node->getText(), OperatorKind::NotOperator);
-}
-void Remangler::manglePrefixOperator(Node *node) {
-  mangleIdentifier(node->getText(), OperatorKind::Prefix);
-}
-void Remangler::manglePostfixOperator(Node *node) {
-  mangleIdentifier(node->getText(), OperatorKind::Postfix);
-}
-void Remangler::mangleInfixOperator(Node *node) {
-  mangleIdentifier(node->getText(), OperatorKind::Infix);
-}
-void Remangler::mangleIdentifier(StringRef ident, OperatorKind operatorKind) {
-  // Mangle normal identifiers as
-  //   count identifier-char+
-  // where the count is the number of characters in the identifier,
-  // and where individual identifier characters represent themselves.
-  if (operatorKind == OperatorKind::NotOperator) {
-    Buffer << ident.size() << ident;
-    return;
-  }
-
-  // Mangle operator identifiers as
-  //   operator ::= 'o' operator-fixity count operator-char+
-  //   operator-fixity ::= 'p' // prefix
-  //   operator-fixity ::= 'P' // postfix
-  //   operator-fixity ::= 'i' // infix
-  // where the count is the number of characters in the operator,
-  // and where the individual operator characters are translated.
-  Buffer << 'o';
-  switch (operatorKind) {
-    case OperatorKind::NotOperator: unreachable("invalid");
-    case OperatorKind::Infix: Buffer << 'i'; break;
-    case OperatorKind::Prefix: Buffer << 'p'; break;
-    case OperatorKind::Postfix: Buffer << 'P'; break;
-  }
-
-  // Mangle ASCII operators directly.
-  Buffer << ident.size();
-  for (char ch : ident) {
-    Buffer << Mangle::translateOperatorChar(ch);
-  }
-}
-
-void Remangler::mangleNumber(Node *node) {
-  mangleIndex(node->getIndex());
-}
-void Remangler::mangleIndex(Node::IndexType value) {
-  if (value == 0) {
-    Buffer << '_';
-  } else {
-    Buffer << (value - 1) << '_';
-  }
-}
-
-void Remangler::mangleGlobal(Node *node) {
-  Buffer << "_T";
-  mangleChildNodes(node);
-}
-
-void Remangler::mangleSuffix(Node *node) {
-  // Just add the suffix back on.
-  Buffer << node->getText();
-}
-
-void Remangler::mangleGenericSpecialization(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleGenericSpecializationPrespecialized(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleGenericSpecializationNotReAbstracted(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleGenericSpecializationInResilienceDomain(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleInlinedGenericFunction(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleGenericPartialSpecialization(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleGenericPartialSpecializationNotReAbstracted(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleGenericSpecializationParam(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleFunctionSignatureSpecialization(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleSpecializationPassID(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleIsSerialized(Node *node) {
-  Buffer << "q";
-}
-
-void Remangler::mangleFunctionSignatureSpecializationReturn(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleFunctionSignatureSpecializationParam(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleFunctionSignatureSpecializationParamPayload(Node *node) {
-  // This should never be called since mangling parameter payloads require
-  // knowing what the parameter kind is.
-  unreachable("This should never be called");
-}
-
-void Remangler::mangleFunctionSignatureSpecializationParamKind(Node *node) {
-  // This should never be called since mangling parameter kinds have influence
-  // on the payloads.
-  unreachable("This should never be called");
-}
-
-void Remangler::mangleRetroactiveConformance(Node *node) {
-  unreachable("Retroactive conformances aren't in the old mangling");
-}
-
-void Remangler::mangleProtocolConformanceRefInTypeModule(Node *node) {
-  unreachable("Protocol conformance references aren't in the old mangling");
-}
-
-void Remangler::mangleProtocolConformanceRefInProtocolModule(Node *node) {
-  unreachable("Protocol conformance references aren't in the old mangling");
-}
-
-void Remangler::mangleProtocolConformanceRefInOtherModule(Node *node) {
-  unreachable("Protocol conformance references aren't in the old mangling");
-}
-
-void Remangler::mangleConcreteProtocolConformance(Node *node) {
-  unreachable("Concrete conformances aren't in the old mangling");
-}
-
-void Remangler::mangleAnyProtocolConformanceList(Node *node) {
-  unreachable("Conformance lists aren't in the old mangling");
-}
-
-void Remangler::mangleDependentAssociatedConformance(Node *node) {
-  unreachable("Dependent associated conformances aren't in the old mangling");
-}
-
-void Remangler::mangleDependentProtocolConformanceRoot(Node *node) {
-  unreachable("Dependent conformances aren't in the old mangling");
-}
-
-void Remangler::mangleDependentProtocolConformanceInherited(Node *node) {
-  unreachable("Dependent conformances aren't in the old mangling");
-}
-
-void Remangler::mangleDependentProtocolConformanceAssociated(Node *node) {
-  unreachable("Dependent conformances aren't in the old mangling");
-}
-
-void Remangler::mangleProtocolConformance(Node *node) {
-  // type, protocol name, context
-  assert(node->getNumChildren() == 3);
-  mangleChildNode(node, 0);
-  mangleProtocolWithoutPrefix(node->begin()[1]);
-  mangleChildNode(node, 2);
-}
-
-void Remangler::mangleObjCAttribute(Node *node) {
-  Buffer << "To";
-}
-
-void Remangler::mangleNonObjCAttribute(Node *node) {
-  Buffer << "TO";
-}
-
-void Remangler::mangleDirectMethodReferenceAttribute(Node *node) {
-  Buffer << "Td";
-}
-
-void Remangler::mangleDynamicAttribute(Node *node) {
-  Buffer << "TD";
-}
-
-void Remangler::mangleVTableAttribute(Node *node) {
-  Buffer << "TV";
-}
-
-void Remangler::mangleGenericTypeMetadataPattern(Node *node) {
-  Buffer << "MP";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleTypeMetadataAccessFunction(Node *node) {
-  Buffer << "Ma";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleTypeMetadataInstantiationCache(Node *node) {
-  Buffer << "MI";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleTypeMetadataInstantiationFunction(Node *node) {
-  Buffer << "Mi";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleTypeMetadataSingletonInitializationCache(Node *node) {
-  Buffer << "Ml";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleTypeMetadataCompletionFunction(Node *node) {
-  Buffer << "Mr";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleTypeMetadataDemanglingCache(Node *node) {
-  unreachable("not supported");
-}
-
-void Remangler::mangleTypeMetadataLazyCache(Node *node) {
-  Buffer << "ML";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleMetaclass(Node *node) {
-  Buffer << "Mm";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleClassMetadataBaseOffset(Node *node) {
-  Buffer << "Mo";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleNominalTypeDescriptor(Node *node) {
-  Buffer << "Mn";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::manglePropertyDescriptor(Node *node) {
-  unreachable("not supported");
-}
-
-void Remangler::mangleTypeMetadata(Node *node) {
-  Buffer << "M";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleFullTypeMetadata(Node *node) {
-  Buffer << "Mf";
-  mangleChildNodes(node); // type
-}
-
-void Remangler::mangleProtocolDescriptor(Node *node) {
-  Buffer << "Mp";
-  mangleProtocolWithoutPrefix(node->begin()[0]);
-}
-
-void Remangler::mangleProtocolRequirementsBaseDescriptor(Node *node) {
-  Buffer << "<protocol-requirements-base-descriptor>";
-}
-
-void Remangler::mangleProtocolWitnessTablePattern(Node *node) {
-  unreachable("todo");
-}
-
-void Remangler::mangleProtocolConformanceDescriptor(Node *node) {
-  Buffer << "Mc";
-  mangleProtocolConformance(node->begin()[0]);
-}
-
-void Remangler::mangleProtocolSelfConformanceDescriptor(Node *node) {
-  Buffer << "MS";
-  mangleProtocol(node->begin()[0]);
-}
-
-void Remangler::manglePartialApplyForwarder(Node *node) {
-  Buffer << "PA__T";
-  mangleSingleChildNode(node); // global
-}
-
-void Remangler::manglePartialApplyObjCForwarder(Node *node) {
-  Buffer << "PAo__T";
-  mangleSingleChildNode(node); // global
-}
-
-void Remangler::mangleMergedFunction(Node *node) {
-  Buffer << "Tm";
-}
-
-void Remangler::mangleDynamicallyReplaceableFunctionImpl(Node *node) {
-  Buffer << "TI";
-}
-
-void Remangler::mangleDynamicallyReplaceableFunctionKey(Node *node) {
-  Buffer << "Tx";
-}
-
-void Remangler::mangleDynamicallyReplaceableFunctionVar(Node *node) {
-  Buffer << "TX";
-}
-
-void Remangler::mangleAsyncAwaitResumePartialFunction(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleAsyncSuspendResumePartialFunction(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleDirectness(Node *node) {
-  auto getChar = [](Directness d) -> char {
-    switch (d) {
-    case Directness::Direct: return 'd';
-    case Directness::Indirect: return 'i';
-    }
-    unreachable("bad directness kind");
-  };
-  Buffer << getChar(Directness(node->getIndex()));
-}
-
-void Remangler::mangleValueWitness(Node *node) {
-  const char *Code = nullptr;
-  switch (ValueWitnessKind(node->getFirstChild()->getIndex())) {
-#define VALUE_WITNESS(MANGLING, NAME) \
-    case ValueWitnessKind::NAME: Code = #MANGLING; break;
-#include "swift/Demangling/ValueWitnessMangling.def"
-  }
-  Buffer << 'w' << Code;
-  mangleChildNode(node, 1); // type
-}
-
-void Remangler::mangleValueWitnessTable(Node *node) {
-  Buffer << "WV";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleConcurrentFunctionType(Node *node) {
-  Buffer << "y";
-}
-
-void Remangler::mangleAsyncAnnotation(Node *node) {
-  Buffer << "Z";
-}
-
-void Remangler::mangleThrowsAnnotation(Node *node) {
-  Buffer << "z";
-}
-
-void Remangler::mangleDifferentiableFunctionType(Node *node) {
-  Buffer << "D";
-  mangleChildNodes(node);
-}
-
-void Remangler::mangleGlobalActorFunctionType(Node *node) {
-  Buffer << "Y" << (char)node->getIndex(); // differentiability kind
-}
-
-void Remangler::mangleFieldOffset(Node *node) {
-  Buffer << "Wv";
-  mangleChildNodes(node); // directness, entity
-}
-
-void Remangler::mangleEnumCase(Node *node) {
-  Buffer << "WC";
-  mangleSingleChildNode(node); // enum case
-}
-
-void Remangler::mangleProtocolSelfConformanceWitnessTable(Node *node) {
-  Buffer << "WS";
-  mangleSingleChildNode(node); // protocol
-}
-
-void Remangler::mangleProtocolWitnessTable(Node *node) {
-  Buffer << "WP";
-  mangleSingleChildNode(node); // protocol conformance
-}
-
-void Remangler::mangleGenericProtocolWitnessTable(Node *node) {
-  Buffer << "WG";
-  mangleSingleChildNode(node); // protocol conformance
-}
-
-void Remangler::mangleResilientProtocolWitnessTable(Node *node) {
-  unreachable("todo");
-}
-
-void Remangler::mangleGenericProtocolWitnessTableInstantiationFunction(
-                                                                  Node *node) {
-  Buffer << "WI";
-  mangleSingleChildNode(node); // protocol conformance
-}
-
-void Remangler::mangleProtocolWitnessTableAccessor(Node *node) {
-  Buffer << "Wa";
-  mangleSingleChildNode(node); // protocol conformance
-}
-
-void Remangler::mangleLazyProtocolWitnessTableAccessor(Node *node) {
-  Buffer << "Wl";
-  mangleChildNodes(node); // type, protocol conformance
-}
-
-void Remangler::mangleLazyProtocolWitnessTableCacheVariable(Node *node) {
-  Buffer << "WL";
-  mangleChildNodes(node); // type, protocol conformance
-}
-
-void Remangler::mangleAssociatedTypeDescriptor(Node *node) {
-  Buffer << "<associated-type-descriptor>";
-}
-
-void Remangler::mangleAssociatedConformanceDescriptor(Node *node) {
-  Buffer << "<associated-conformance-descriptor>";
-}
-
-void Remangler::mangleDefaultAssociatedConformanceAccessor(Node *node) {
-  Buffer << "<default-associated-conformance-descriptor>";
-}
-
-void Remangler::mangleBaseConformanceDescriptor(Node *node) {
-  Buffer << "<base-conformance-descriptor>";
-}
-
-void Remangler::mangleAssociatedTypeMetadataAccessor(Node *node) {
-  Buffer << "Wt";
-  mangleChildNodes(node); // protocol conformance, identifier
-}
-
-void Remangler::mangleDefaultAssociatedTypeMetadataAccessor(Node *node) {
-  Buffer << "<default-associated-type-metadata-accessor>";
-}
-
-void Remangler::mangleAssociatedTypeWitnessTableAccessor(Node *node) {
-  Buffer << "WT";
-  assert(node->getNumChildren() == 3);
-  mangleChildNode(node, 0); // protocol conformance
-  mangleChildNode(node, 1); // type
-  mangleProtocolWithoutPrefix(node->begin()[2]); // type
-}
-
-void Remangler::mangleBaseWitnessTableAccessor(Node *node) {
-  Buffer << "<base-witness-table-accessor>";
-}
-
-void Remangler::mangleReabstractionThunkHelper(Node *node) {
-  Buffer << "<reabstraction-thunk-helper>";
-}
-
-void Remangler::mangleReabstractionThunkHelperWithSelf(Node *node) {
-  Buffer << "<reabstraction-thunk-helper-with-self>";
-}
-
-void Remangler::mangleReabstractionThunk(Node *node) {
-  Buffer << "<reabstraction-thunk>";
-}
-
-void Remangler::mangleReabstractionThunkHelperWithGlobalActor(Node *node) {
-  Buffer << "<reabstraction-thunk-helper-with-global-actor>";
-}
-
-void Remangler::mangleAutoDiffFunction(Node *node, EntityContext &ctx) {
-  Buffer << "<autodiff-function>";
-}
-
-void Remangler::mangleAutoDiffDerivativeVTableThunk(Node *node) {
-  Buffer << "<autodiff-derivative-vtable-thunk>";
-}
-
-void Remangler::mangleAutoDiffSelfReorderingReabstractionThunk(Node *node) {
-  Buffer << "<autodiff-self-reordering-reabstraction-thunk>";
-}
-
-void Remangler::mangleAutoDiffSubsetParametersThunk(Node *node) {
-  Buffer << "<autodiff-subset-parameters-thunk>";
-}
-
-void Remangler::mangleAutoDiffFunctionKind(Node *node) {
-  Buffer << "<autodiff-function-kind>";
-}
-
-void Remangler::mangleDifferentiabilityWitness(Node *node) {
-  Buffer << "<differentiability-witness>";
-}
-
-void Remangler::mangleIndexSubset(Node *node) {
-  Buffer << "<index-subset>";
-}
-
-void Remangler::mangleProtocolSelfConformanceWitness(Node *node) {
-  Buffer << "TS";
-  mangleSingleChildNode(node); // entity
-}
-
-void Remangler::mangleProtocolWitness(Node *node) {
-  Buffer << "TW";
-  mangleChildNodes(node); // protocol conformance, entity
-}
-
-void Remangler::mangleFunction(Node *node, EntityContext &ctx) {
-  mangleNamedAndTypedEntity(node, 'F', "", ctx);
-}
-
-void Remangler::mangleVariable(Node *node, EntityContext &ctx) {
-  mangleNamedAndTypedEntity(node, 'v', "", ctx);
-}
-
-void Remangler::mangleSubscript(Node *node, EntityContext &ctx) {
-  mangleNamedAndTypedEntity(node, 'i', "", ctx);
-}
-
-void Remangler::mangleAccessor(Node *storageNode, StringRef accessorCode,
-                               EntityContext &ctx) {
-  Buffer << 'F';
-  mangleEntityContext(storageNode->getChild(0), ctx);
-  Buffer << accessorCode;
-
-  auto mangleAccessorType = [&](unsigned TypeIndex) {
-    auto LabelList = storageNode->getChild(TypeIndex);
-    if (LabelList->getKind() == Node::Kind::LabelList) {
-      auto Type = storageNode->getChild(TypeIndex + 1);
-      mangleEntityType(applyParamLabels(LabelList, Type, Factory), ctx);
-    } else {
-      mangleEntityType(storageNode->getChild(TypeIndex), ctx);
-    }
-  };
-
-  switch (storageNode->getKind()) {
-  case Demangle::Node::Kind::Variable: {
-    mangleChildNode(storageNode, 1);
-    mangleAccessorType(2);
-    break;
-  }
-
-  case Demangle::Node::Kind::Subscript: {
-    auto NumChildren = storageNode->getNumChildren();
-    assert(NumChildren <= 4);
-
-    auto PrivateName = storageNode->getChild(NumChildren - 1);
-    if (PrivateName->getKind() == Node::Kind::PrivateDeclName)
-      mangle(PrivateName);
-
-    mangleIdentifier("subscript", OperatorKind::NotOperator);
-    mangleAccessorType(1);
-    break;
-  }
-  default:
-      unreachable("Not a storage node");
-  }
-}
-
-void Remangler::mangleInitializer(Node *node, EntityContext &ctx) {
-  mangleSimpleEntity(node, 'I', "i", ctx);
-}
-
-void Remangler::manglePropertyWrapperBackingInitializer(Node *node,
-                                                        EntityContext &ctx) {
-  mangleSimpleEntity(node, 'I', "P", ctx);
-}
-
-void Remangler::manglePropertyWrapperInitFromProjectedValue(Node *node,
-                                                            EntityContext &ctx) {
-  mangleSimpleEntity(node, 'I', "W", ctx);
-}
-
-void Remangler::mangleDefaultArgumentInitializer(Node *node,
-                                                 EntityContext &ctx) {
-  mangleNamedEntity(node, 'I', "A", ctx);
-}
-
-void Remangler::mangleAsyncFunctionPointer(Node *node) {
-  Buffer << "Tu";
-}
-
-void Remangler::mangleDeallocator(Node *node, EntityContext &ctx) {
-  mangleSimpleEntity(node, 'F', "D", ctx);
-}
-
-void Remangler::mangleDestructor(Node *node, EntityContext &ctx) {
-  mangleSimpleEntity(node, 'F', "d", ctx);
-}
-
-void Remangler::mangleAllocator(Node *node, EntityContext &ctx) {
-  mangleTypedEntity(node, 'F', "C", ctx);
-}
-
-void Remangler::mangleConstructor(Node *node, EntityContext &ctx) {
-  mangleTypedEntity(node, 'F', "c", ctx);
-}
-
-void Remangler::mangleIVarInitializer(Node *node, EntityContext &ctx) {
-  mangleSimpleEntity(node, 'F', "e", ctx);
-}
-
-void Remangler::mangleIVarDestroyer(Node *node, EntityContext &ctx) {
-  mangleSimpleEntity(node, 'F', "E", ctx);
-}
-
-void Remangler::mangleGetter(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "g", ctx);
-}
-
-void Remangler::mangleGlobalGetter(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "G", ctx);
-}
-
-void Remangler::mangleSetter(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "s", ctx);
-}
-
-void Remangler::mangleMaterializeForSet(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "m", ctx);
-}
-
-void Remangler::mangleWillSet(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "w", ctx);
-}
-
-void Remangler::mangleDidSet(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "W", ctx);
-}
-
-void Remangler::mangleOwningMutableAddressor(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "aO", ctx);
-}
-
-void Remangler::mangleNativeOwningMutableAddressor(Node *node,
-                                                   EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "ao", ctx);
-}
-
-void Remangler::mangleNativePinningMutableAddressor(Node *node,
-                                                    EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "ap", ctx);
-}
-
-void Remangler::mangleUnsafeMutableAddressor(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "au", ctx);
-}
-
-void Remangler::mangleOwningAddressor(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "lO", ctx);
-}
-
-void Remangler::mangleNativeOwningAddressor(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "lo", ctx);
-}
-
-void Remangler::mangleNativePinningAddressor(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "lp", ctx);
-}
-
-void Remangler::mangleUnsafeAddressor(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "lu", ctx);
-}
-
-void Remangler::mangleReadAccessor(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "r", ctx);
-}
-
-void Remangler::mangleModifyAccessor(Node *node, EntityContext &ctx) {
-  mangleAccessor(node->getFirstChild(), "M", ctx);
-}
-
-void Remangler::mangleExplicitClosure(Node *node, EntityContext &ctx) {
-  mangleNamedAndTypedEntity(node, 'F', "U", ctx); // name is index
-}
-
-void Remangler::mangleImplicitClosure(Node *node, EntityContext &ctx) {
-  mangleNamedAndTypedEntity(node, 'F', "u", ctx); // name is index
-}
-
-void Remangler::mangleStatic(Node *node, EntityContext &ctx) {
-  Buffer << 'Z';
-  mangleEntityContext(node->getChild(0), ctx);
-}
-
-void Remangler::mangleSimpleEntity(Node *node, char basicKind,
-                                   StringRef entityKind,
-                                   EntityContext &ctx) {
-  assert(node->getNumChildren() == 1);
-  Buffer << basicKind;
-  mangleEntityContext(node->begin()[0], ctx);
-  Buffer << entityKind;
-}
-
-void Remangler::mangleNamedEntity(Node *node, char basicKind,
-                                  StringRef entityKind,
-                                  EntityContext &ctx,
-                                  StringRef artificialPrivateDiscriminator) {
-  assert(node->getNumChildren() == 2);
-  if (basicKind != '\0') Buffer << basicKind;
-  mangleEntityContext(node->begin()[0], ctx);
-  Buffer << entityKind;
-  
-  auto privateDiscriminator = ctx.takeAnonymousContextDiscriminator();
-  if (!privateDiscriminator.empty() && isdigit(privateDiscriminator[0]))
-    privateDiscriminator = "_" + privateDiscriminator;
-  if (!artificialPrivateDiscriminator.empty())
-    privateDiscriminator.append(artificialPrivateDiscriminator.data(),
-                                artificialPrivateDiscriminator.size());
-  
-  // Include the artificial private discriminator if one was given.
-  auto name = node->getChild(1);
-  if (!privateDiscriminator.empty()
-      && name->getKind() == Node::Kind::Identifier) {
-    Buffer << 'P';
-    mangleIdentifier(privateDiscriminator, OperatorKind::NotOperator);
-  }
-  mangle(name);
-}
-
-void Remangler::mangleTypedEntity(Node *node, char basicKind,
-                                  StringRef entityKind,
-                                  EntityContext &ctx) {
-  assert(node->getNumChildren() == 2 || node->getNumChildren() == 3);
-  Buffer << basicKind;
-  mangleEntityContext(node->begin()[0], ctx);
-  Buffer << entityKind;
-
-  if (node->begin()[1]->getKind() == Node::Kind::LabelList) {
-    auto LabelList = node->begin()[1];
-    auto Type = node->begin()[2];
-    mangleEntityType(applyParamLabels(LabelList, Type, Factory), ctx);
-  } else {
-    mangleEntityType(node->begin()[1], ctx);
-  }
-}
-
-void Remangler::mangleNamedAndTypedEntity(Node *node, char basicKind,
-                                          StringRef entityKind,
-                                          EntityContext &ctx) {
-  assert(node->getNumChildren() == 3 || node->getNumChildren() == 4);
-  Buffer << basicKind;
-  mangleEntityContext(node->begin()[0], ctx);
-  Buffer << entityKind;
-  mangleChildNode(node, 1); // decl name / index
-
-  if (node->begin()[2]->getKind() == Node::Kind::LabelList) {
-    auto LabelList = node->begin()[2];
-    auto Type = node->begin()[3];
-    mangleEntityType(applyParamLabels(LabelList, Type, Factory), ctx);
-  } else {
-    mangleEntityType(node->begin()[2], ctx);
-  }
-}
-
-void Remangler::mangleEntityContext(Node *node, EntityContext &ctx) {
-  // Remember that we're mangling a context.
-  EntityContext::ManglingContextRAII raii(ctx);
-
-  // Deal with bound generic types.
-  switch (node->getKind()) {
-    case Node::Kind::BoundGenericStructure:
-    case Node::Kind::BoundGenericEnum:
-    case Node::Kind::BoundGenericClass:
-    case Node::Kind::BoundGenericOtherNominalType:
-    case Node::Kind::BoundGenericTypeAlias:
-      mangleAnyNominalType(node, ctx);
-      return;
-
-    default:
-      break;
-  }
-
-  switch (node->getKind()) {
-#define NODE(ID)                                \
-  case Node::Kind::ID:
-#define CONTEXT_NODE(ID)
-#include "swift/Demangling/DemangleNodes.def"
-    unreachable("not a context node");
-
-#define NODE(ID)
-#define CONTEXT_NODE(ID)                        \
-  case Node::Kind::ID:                          \
-    return mangle##ID(node, ctx);
-#include "swift/Demangling/DemangleNodes.def"
-  }
-  unreachable("bad node kind");
-}
-
-void Remangler::mangleEntityType(Node *node, EntityContext &ctx) {
-  assert(node->getKind() == Node::Kind::Type);
-  assert(node->getNumChildren() == 1);
-  node = node->begin()[0];
-
-  // Expand certain kinds of type within the entity context.
-  switch (node->getKind()) {
-  case Node::Kind::NoEscapeFunctionType:
-  case Node::Kind::FunctionType:
-  case Node::Kind::UncurriedFunctionType: {
-    Buffer << ((node->getKind() == Node::Kind::FunctionType ||
-             node->getKind() == Node::Kind::NoEscapeFunctionType)
-                ? 'F'
-                : 'f');
-    unsigned inputIndex = node->getNumChildren() - 2;
-    assert(inputIndex <= 1);
-    for (unsigned i = 0; i <= inputIndex; ++i)
-      mangle(node->begin()[i]);
-    auto returnType = node->begin()[inputIndex+1];
-    assert(returnType->getKind() == Node::Kind::ReturnType);
-    assert(returnType->getNumChildren() == 1);
-    mangleEntityType(returnType->begin()[0], ctx);
-    return;
-  }
-  default:
-    mangle(node);
-    return;
-  }
-}
-
-void Remangler::mangleLocalDeclName(Node *node) {
-  Buffer << 'L';
-  mangleChildNodes(node); // index, identifier
-}
-
-void Remangler::manglePrivateDeclName(Node *node) {
-  Buffer << 'P';
-  mangleChildNodes(node); // identifier, identifier
-}
-
-void Remangler::mangleRelatedEntityDeclName(Node *node) {
-  // Non-round-trip mangling: pretend we have a private discriminator "$A" for a
-  // related entity "A".
-  NodePointer kindNode = node->getFirstChild();
-  Buffer << 'P' << (kindNode->getText().size() + 1) << '$' << kindNode->getText();
-  mangleChildNode(node, 1);
-}
-
-void Remangler::mangleTypeMangling(Node *node) {
-  Buffer << 't';
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleType(Node *node) {
-  mangleSingleChildNode(node);
-}
-
-template <size_t N> 
-static bool stripPrefix(StringRef &string, const char (&data)[N]) {
-  constexpr size_t prefixLength = N - 1;
-  if (!string.startswith(StringRef(data, prefixLength)))
-    return false;
-  string = string.drop_front(prefixLength);
-  return true;
-}
-
-void Remangler::mangleBuiltinTypeName(Node *node) {
-  Buffer << 'B';
-  StringRef text = node->getText();
-
-  if (text == "Builtin.BridgeObject") {
-    Buffer << 'b';
-  } else if (text == "Builtin.UnsafeValueBuffer") {
-    Buffer << 'B';
-  } else if (text == "Builtin.UnknownObject") {
-    Buffer << 'O';
-  } else if (text == "Builtin.NativeObject") {
-    Buffer << 'o';
-  } else if (text == "Builtin.RawPointer") {
-    Buffer << 'p';
-  } else if (text == "Builtin.Word") {
-    Buffer << 'w';
-  } else if (stripPrefix(text, "Builtin.Int")) {
-    Buffer << 'i' << text << '_';
-  } else if (stripPrefix(text, "Builtin.FPIEEE")) {
-    Buffer << 'f' << text << '_';
-  } else if (stripPrefix(text, "Builtin.Vec")) {
-    // Avoid using StringRef::split because its definition is not
-    // provided in the header so that it requires linking with libSupport.a.
-    size_t splitIdx = text.find('x');
-    Buffer << 'v' << text.substr(0, splitIdx) << 'B';
-    auto element = text.substr(splitIdx).substr(1);
-    if (element == "RawPointer") {
-      Buffer << 'p';
-    } else if (stripPrefix(element, "Float")) {
-      Buffer << 'f' << element << '_';
-    } else if (stripPrefix(element, "Int")) {
-      Buffer << 'i' << element << '_';
-    } else {
-      unreachable("unexpected builtin vector type");
-    }
-  } else {
-    unreachable("unexpected builtin type");
-  }
-}
-
-void Remangler::mangleTypeAlias(Node *node, EntityContext &ctx) {
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleFunctionType(Node *node) {
-  Buffer << 'F';
-  mangleChildNodes(node); // argument tuple, result type
-}
-
-void Remangler::mangleUncurriedFunctionType(Node *node) {
-  Buffer << 'f';
-  mangleChildNodes(node); // argument tuple, result type
-}
-
-void Remangler::mangleObjCBlock(Node *node) {
-  Buffer << 'b';
-  mangleChildNodes(node); // argument tuple, result type
-}
-
-void Remangler::mangleEscapingObjCBlock(Node *node) {
-  // We shouldn't ever be remangling anything with a DWARF-only mangling.
-  Buffer << "<escaping block type>";
-}
-
-void Remangler::mangleCFunctionPointer(Node *node) {
-  Buffer << 'c';
-  mangleChildNodes(node); // argument tuple, result type
-}
-
-void Remangler::mangleAutoClosureType(Node *node) {
-  Buffer << 'K';
-  mangleChildNodes(node); // argument tuple, result type
-}
-
-void Remangler::mangleNoEscapeFunctionType(Node *node) {
-  Buffer << 'F';
-  mangleChildNodes(node); // argument tuple, result type
-}
-
-void Remangler::mangleEscapingAutoClosureType(Node *node) {
-  Buffer << 'K';
-  mangleChildNodes(node); // argument tuple, result type
-}
-
-void Remangler::mangleThinFunctionType(Node *node) {
-  Buffer << "Xf";
-  mangleChildNodes(node); // argument tuple, result type
-}
-
-void Remangler::mangleArgumentTuple(Node *node) {
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleReturnType(Node *node) {
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleImplFunctionType(Node *node) {
-  Buffer << "XF";
-  auto i = node->begin(), e = node->end();
-  if (i != e && (*i)->getKind() == Node::Kind::ImplConvention) {
-    StringRef text = (*i)->getText();
-    ++i;
-    if (text == "@callee_unowned") {
-      Buffer << 'd';
-    } else if (text == "@callee_guaranteed") {
-      Buffer << 'g';
-    } else if (text == "@callee_owned") {
-      Buffer << 'o';
-    } else {
-      unreachable("bad callee convention");
-    }
-  } else {
-    Buffer << 't';
-  }
-  for (; i != e &&
-         (*i)->getKind() == Node::Kind::ImplFunctionAttribute; ++i) {
-    mangle(*i); // impl function attribute
-  }
-  if (i != e &&
-      ((*i)->getKind() == Node::Kind::DependentGenericSignature ||
-       (*i)->getKind() == Node::Kind::DependentPseudogenericSignature)) {
-    Buffer << ((*i)->getKind() == Node::Kind::DependentGenericSignature
-              ? 'G' : 'g');
-    mangleDependentGenericSignature((*i));
-    ++i;
-  }
-  Buffer << '_';
-  for (; i != e && (*i)->getKind() == Node::Kind::ImplParameter; ++i) {
-    mangleImplParameter(*i);
-  }
-  Buffer << '_';
-  mangleNodes(i, e); // impl results
-  Buffer << '_';
-}
-
-void Remangler::mangleImplFunctionAttribute(Node *node) {
-  StringRef text = node->getText();
-  if (text == "@yield_once") {
-    Buffer << "A";
-  } else if (text == "@yield_many") {
-    Buffer << "G";
-  } else if (text == "@Sendable") {
-    Buffer << "h";
-  } else if (text == "@async") {
-    Buffer << "H";
-  } else {
-    unreachable("bad impl-function-attribute");
-  }
-}
-
-void Remangler::mangleImplFunctionConvention(Node *node) {
-  mangle(node->getChild(0));
-}
-
-void Remangler::mangleImplFunctionConventionName(Node *node) {
-  StringRef text = node->getText();
-  if (text == "block") {
-    Buffer << "Cb";
-  } else if (text == "c") {
-    Buffer << "Cc";
-  } else if (text == "method") {
-    Buffer << "Cm";
-  } else if (text == "objc_method") {
-    Buffer << "CO";
-  } else if (text == "witness_method") {
-    Buffer << "Cw";
-  } else {
-    unreachable("bad impl-function-convention-name");
-  }
-}
-
-void Remangler::mangleClangType(Node *node) { unreachable("unsupported"); }
-
-void Remangler::mangleImplParameter(Node *node) {
-  assert(node->getNumChildren() == 2);
-  mangleChildNodes(node); // impl convention, type
-}
-
-void Remangler::mangleImplErrorResult(Node *node) {
-  assert(node->getNumChildren() == 2);
-  Buffer << 'z';
-  mangleChildNodes(node); // impl convention, type
-}
-
-void Remangler::mangleImplResult(Node *node) {
-  assert(node->getNumChildren() == 2);
-  mangleChildNodes(node); // impl convention, type
-}
-
-void Remangler::mangleImplYield(Node *node) {
-  assert(node->getNumChildren() == 2);
-  Buffer << 'Y';
-  mangleChildNodes(node); // impl convention, type
-}
-
-void Remangler::mangleImplDifferentiabilityKind(Node *node) {
-  // TODO(TF-750): Check if this code path actually triggers and add a test.
-  Buffer << (char)node->getIndex();
-}
-
-void Remangler::mangleImplEscaping(Node *node) {
-  // The old mangler does not encode escaping.
-}
-
-void Remangler::mangleImplPatternSubstitutions(Node *node) {
-  // The old mangler does not encode substituted function types.
-}
-
-void Remangler::mangleImplInvocationSubstitutions(Node *node) {
-  // The old mangler does not encode substituted function types.
-}
-
-void Remangler::mangleImplConvention(Node *node) {
-  assert(node->getKind() == Node::Kind::ImplConvention);
-  StringRef text = node->getText();
-  if (text == "@autoreleased") {
-    Buffer << 'a';
-  } else if (text == "@unowned") {
-    Buffer << 'd';
-  } else if (text == "@unowned_inner_pointer") {
-    Buffer << 'D'; // only in results
-  } else if (text == "@guaranteed") {
-    Buffer << 'g';
-  } else if (text == "@deallocating") {
-    Buffer << 'e';
-  } else if (text == "@in") {
-    Buffer << 'i'; // only in parameters
-  } else if (text == "@out") {
-    Buffer << 'i'; // only in results
-  } else if (text == "@inout") {
-    Buffer << 'l';
-  } else if (text == "@owned") {
-    Buffer << 'o';
-  } else {
-    unreachable("invalid impl convention");
-  }
-}
-
-void Remangler::mangleImplParameterResultDifferentiability(Node *node) {
-  assert(node->getKind() == Node::Kind::ImplDifferentiabilityKind);
-  StringRef text = node->getText();
-  // Empty string represents default differentiability.
-  if (text.empty())
-    return;
-  if (text == "@noDerivative") {
-    Buffer << 'w';
-    return;
-  }
-  unreachable("Invalid impl differentiability");
-}
-
-void Remangler::mangleDynamicSelf(Node *node) {
-  Buffer << 'D';
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleErrorType(Node *node) {
-  Buffer << "ERR";
-}
-
-void Remangler::mangleSILBoxType(Node *node) {
-  Buffer << 'X' << 'b';
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleMetatype(Node *node) {
-  if (node->getNumChildren() == 1) {
-    Buffer << 'M';
-    mangleSingleChildNode(node); // type
-  } else {
-    assert(node->getNumChildren() == 2);
-    Buffer << "XM";
-    mangleChildNodes(node); // metatype representation, type
-  }
-}
-
-void Remangler::mangleExistentialMetatype(Node *node) {
-  if (node->getNumChildren() == 1) {
-    Buffer << "PM";
-    mangleSingleChildNode(node); // type
-  } else {
-    assert(node->getNumChildren() == 2);
-    Buffer << "XPM";
-    mangleChildNodes(node); // metatype representation, type
-  }
-}
-
-void Remangler::mangleMetatypeRepresentation(Node *node) {
-  StringRef text = node->getText();
-  if (text == "@thin") {
-    Buffer << 't';
-  } else if (text == "@thick") {
-    Buffer << 'T';
-  } else if (text == "@objc_metatype") {
-    Buffer << 'o';
-  } else {
-    unreachable("bad metatype representation");
-  }
-}
-
-void Remangler::mangleProtocolList(Node *node) {
-  // In its usual use as a type, this gets a prefix 'P'.
-  Buffer << 'P';
-  mangleProtocolListWithoutPrefix(node);
-}
-
-void Remangler::mangleProtocolListWithoutPrefix(Node *node,
-                                                Node *additionalProto) {
-  assert(node->getKind() == Node::Kind::ProtocolList);
-  assert(node->getNumChildren() == 1);
-  auto typeList = node->begin()[0];
-  assert(typeList->getKind() == Node::Kind::TypeList);
-  for (auto &child : *typeList) {
-    mangleProtocolWithoutPrefix(child);
-  }
-  if (additionalProto) {
-    mangleProtocolWithoutPrefix(additionalProto);
-  }
-  Buffer << '_';
-}
-
-#define REF_STORAGE(Name, ...) \
-  void Remangler::mangle##Name(Node *node) { \
-    Buffer << manglingOf(ReferenceOwnership::Name); \
-    mangleSingleChildNode(node); /* type */ \
-  }
-#include "swift/AST/ReferenceStorage.def"
-
-void Remangler::mangleShared(Node *node) {
-  Buffer << 'h';
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleOwned(Node *node) {
-  Buffer << 'n';
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleInOut(Node *node) {
-  Buffer << 'R';
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleIsolated(Node *node) {
-  Buffer << "Yi";
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleNoDerivative(Node *node) {
-  Buffer << 'k';
-  mangleSingleChildNode(node); // type
-}
-
-void Remangler::mangleTuple(Node *node) {
-  size_t NumElems = node->getNumChildren();
-  if (NumElems > 0 &&
-      node->getChild(NumElems - 1)->getFirstChild()->getKind() ==
-      Node::Kind::VariadicMarker) {
-    Buffer << 't';
-  } else {
-    Buffer << 'T';
-  }
-  mangleChildNodes(node); // tuple elements
-  Buffer << '_';
-}
-
-void Remangler::mangleTupleElement(Node *node) {
-  mangleChildNodes(node); // tuple element name?, type
-}
-
-void Remangler::mangleTupleElementName(Node *node) {
-  mangleIdentifier(node->getText(), OperatorKind::NotOperator);
-}
-
-void Remangler::mangleDependentGenericType(Node *node) {
-  Buffer << 'u';
-  mangleChildNodes(node); // generic signature, type
-}
-
-void Remangler::mangleDependentPseudogenericSignature(Node *node) {
-  mangleDependentGenericSignature(node);
-}
-
-void Remangler::mangleDependentGenericSignature(Node *node) {
-  auto i = node->begin(), e = node->end();
-  
-  // If there's only one generic param, mangle nothing.
-  if (node->getNumChildren() >= 1
-      && node->getChild(0)->getKind() == Node::Kind::DependentGenericParamCount
-      && node->getChild(0)->getIndex() == 1
-      && (node->getNumChildren() == 1
-          || node->getChild(1)->getKind() != Node::Kind::DependentGenericParamCount))
-  {
-    ++i;
-    goto mangle_requirements;
-  }
-  
-  // Remangle generic params.
-  for (; i != e &&
-         (*i)->getKind() == Node::Kind::DependentGenericParamCount; ++i) {
-    auto count = *i;
-    if (count->getIndex() > 0)
-      mangleIndex(count->getIndex() - 1);
-    else
-      Buffer << 'z';
-  }
-  
-mangle_requirements:
-  if (i == e) { // no generic requirements
-    Buffer << 'r';
-    return;
-  }
-  
-  Buffer << 'R';
-  mangleNodes(i, e); // generic requirements
-  Buffer << 'r';
-}
-
-void Remangler::mangleDependentGenericParamCount(Node *node) {
-  unreachable("handled inline in DependentGenericSignature");
-}
-
-void Remangler::mangleDependentGenericConformanceRequirement(Node *node) {
-  mangleConstrainedType(node->getChild(0));
-  // If the constraint represents a protocol, use the shorter mangling.
-  if (node->getNumChildren() == 2
-      && node->getChild(1)->getKind() == Node::Kind::Type
-      && node->getChild(1)->getNumChildren() == 1
-      && node->getChild(1)->getChild(0)->getKind() == Node::Kind::Protocol) {
-    mangleProtocolWithoutPrefix(node->getChild(1)->getChild(0));
-    return;
-  }
-
-  mangle(node->getChild(1));
-}
-
-void Remangler::mangleDependentGenericSameTypeRequirement(Node *node) {
-  mangleConstrainedType(node->getChild(0));
-  Buffer << 'z';
-  mangle(node->getChild(1));
-}
-
-void Remangler::mangleDependentGenericLayoutRequirement(Node *node) {
-  mangleConstrainedType(node->getChild(0));
-  Buffer << 'l';
-  auto id =  node->getChild(1)->getText();
-  auto size = -1;
-  if (node->getNumChildren() > 2) {
-    size = node->getChild(2)->getIndex();
-  }
-  int alignment = -1;
-  if (node->getNumChildren() > 3) {
-    alignment = node->getChild(3)->getIndex();
-  }
-  Buffer << id;
-  if (size >= 0)
-    Buffer << size;
-  if (alignment >= 0) {
-    Buffer << "_" << alignment;
-  }
-}
-
-void Remangler::mangleConstrainedType(Node *node) {
-  if (node->getFirstChild()->getKind()
-        == Node::Kind::DependentGenericParamType) {
-    // Can be mangled without an introducer.
-    mangleDependentGenericParamIndex(node->getFirstChild());
-  } else {
-    mangle(node);
-  }
-}
-
-void Remangler::mangleAssociatedType(Node *node) {
-  if (node->hasChildren()) {
-    assert(node->getNumChildren() == 1);
-    mangleProtocolListWithoutPrefix(*node->begin());
-  } else {
-    Buffer << '_';
-  }
-}
-
-void Remangler::mangleDeclContext(Node *node) {
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleExtension(Node *node, EntityContext &ctx) {
-  assert(node->getNumChildren() == 2 || node->getNumChildren() == 3);
-  if (node->getNumChildren() == 3) {
-    Buffer << 'e';
-  } else {
-    Buffer << 'E';
-  }
-  mangleEntityContext(node->begin()[0], ctx); // module
-  if (node->getNumChildren() == 3) {
-    mangleDependentGenericSignature(node->begin()[2]); // generic sig
-  }
-
-  mangleEntityContext(node->begin()[1], ctx); // context
-}
-
-void Remangler::mangleAnonymousContext(Node *node, EntityContext &ctx) {
-  mangleEntityContext(node->getChild(1), ctx);
-
-  // Since we can't change the old mangling, mangle an anonymous context by
-  // introducing a private discriminator onto its child contexts.
-  ctx.setAnonymousContextDiscriminator(node->getChild(0)->getText());
-}
-
-void Remangler::mangleModule(Node *node, EntityContext &ctx) {
-  SubstitutionEntry entry;
-  if (trySubstitution(node, entry)) return;
-
-  // Module types get an M prefix, but module contexts don't.
-  if (!ctx.isAsContext()) Buffer << 'M';
-  mangleIdentifier(node->getText(), OperatorKind::NotOperator);
-  addSubstitution(entry);
-}
-
-void Remangler::mangleAssociatedTypeRef(Node *node) {
-  SubstitutionEntry entry;
-  if (trySubstitution(node, entry)) return;
-  Buffer << "Q";
-  mangleChildNodes(node); // type, identifier
-  addSubstitution(entry);
-}
-
-void Remangler::mangleDependentMemberType(Node *node) {
-  Vector<Node *> members;
-  Node *base = node;
-  do {
-    members.push_back(base, Factory);
-    base = base->getFirstChild()->getFirstChild();
-  } while (base->getKind() == Node::Kind::DependentMemberType);
-
-  assert(base->getKind() == Node::Kind::DependentGenericParamType
-         && "dependent members not based on a generic param are non-canonical"
-            " and shouldn't need remangling");
-  assert(members.size() >= 1);
-  if (members.size() == 1) {
-    Buffer << 'w';
-    mangleDependentGenericParamIndex(base);
-    mangle(members[0]->getChild(1));
-  } else {
-    Buffer << 'W';
-    mangleDependentGenericParamIndex(base);
-
-    for (unsigned i = 1, n = members.size(); i <= n; ++i) {
-      Node *member = members[n - i];
-      mangle(member->getChild(1));
-    }
-    Buffer << '_';
-  }
-}
-
-void Remangler::mangleDependentAssociatedTypeRef(Node *node) {
-  SubstitutionEntry entry;
-  if (trySubstitution(node, entry)) return;
-
-  if (node->getNumChildren() > 1) {
-    Buffer << 'P';
-    mangleProtocolWithoutPrefix(node->getChild(1));
-  }
-  mangleIdentifier(node->getFirstChild());
-
-  addSubstitution(entry);
-}
-
-void Remangler::mangleDependentGenericParamIndex(Node *node) {
-  auto depth = node->getChild(0)->getIndex();
-  auto index = node->getChild(1)->getIndex();
-
-  if (depth != 0) {
-    Buffer << 'd';
-    mangleIndex(depth - 1);
-    mangleIndex(index);
-    return;
-  }
-  if (index != 0) {
-    mangleIndex(index - 1);
-    return;
-  }
-
-  // depth == index == 0
-  Buffer << 'x';
-}
-
-void Remangler::mangleDependentGenericParamType(Node *node) {
-  if (node->getChild(0)->getIndex() == 0
-      && node->getChild(1)->getIndex() == 0) {
-    Buffer << 'x';
-    return;
-  }
-
-  Buffer << 'q';
-  mangleDependentGenericParamIndex(node);
-}
-
-void Remangler::mangleIndex(Node *node) {
-  mangleIndex(node->getIndex());
-}
-
-void Remangler::mangleUnknownIndex(Node *node) {
-  unreachable("should not be reached in an arbitrary context");
-}
-
-void Remangler::mangleProtocol(Node *node, EntityContext &ctx) {
-  mangleNominalType(node, 'P', ctx);
-}
-
-void Remangler::mangleProtocolWithoutPrefix(Node *node) {
-  if (mangleStandardSubstitution(node))
-    return;
-
-  if (node->getKind() == Node::Kind::Type) {
-    assert(node->getNumChildren() == 1);
-    node = node->begin()[0];
-  }
-
-  assert(node->getKind() == Node::Kind::Protocol);
-  EntityContext ctx;
-  mangleNominalType(node, '\0', ctx);
-}
-
-void Remangler::mangleGenericArgs(Node *node, EntityContext &ctx) {
-  switch (node->getKind()) {
-  case Node::Kind::Structure:
-  case Node::Kind::Enum:
-  case Node::Kind::Class: {
-    NodePointer parentOrModule = node->getChild(0);
-    mangleGenericArgs(parentOrModule, ctx);
-
-    // No generic arguments at this level
-    Buffer << '_';
-    break;
-  }
-
-  case Node::Kind::BoundGenericStructure:
-  case Node::Kind::BoundGenericEnum:
-  case Node::Kind::BoundGenericClass: {
-    NodePointer unboundType = node->getChild(0);
-    assert(unboundType->getKind() == Node::Kind::Type);
-    NodePointer nominalType = unboundType->getChild(0);
-    NodePointer parentOrModule = nominalType->getChild(0);
-    mangleGenericArgs(parentOrModule, ctx);
-
-    mangleTypeList(node->getChild(1));
-    break;
-  }
-
-  case Node::Kind::AnonymousContext:
-  case Node::Kind::Extension: {
-    mangleGenericArgs(node->getChild(1), ctx);
-    break;
-  }
-
-  default:
-    break;
-  }
-}
-
-void Remangler::mangleAnyNominalType(Node *node, EntityContext &ctx) {
-  if (isSpecialized(node)) {
-    Buffer << 'G';
-
-    NodePointer unboundType = getUnspecialized(node, Factory);
-
-    mangleAnyNominalType(unboundType, ctx);
-    mangleGenericArgs(node, ctx);
-    return;
-  }
-
-  switch (node->getKind()) {
-  case Node::Kind::OtherNominalType:
-    // Mangle unknown type kinds as structures since we can't change the old
-    // mangling. Give the mangling an artificial "private discriminator" so that
-    // clients who understand the old mangling know this is an unstable
-    // mangled name.
-    mangleNominalType(node, 'V', ctx, "_UnknownTypeKind");
-    break;
-  case Node::Kind::Structure:
-    mangleNominalType(node, 'V', ctx);
-    break;
-  case Node::Kind::Enum:
-    mangleNominalType(node, 'O', ctx);
-    break;
-  case Node::Kind::Class:
-    mangleNominalType(node, 'C', ctx);
-    break;
-  case Node::Kind::TypeAlias:
-    mangleNominalType(node, 'a', ctx);
-    break;
-  default:
-    unreachable("bad nominal type kind");
-  }
-}
-
-void Remangler::mangleStructure(Node *node, EntityContext &ctx) {
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleEnum(Node *node, EntityContext &ctx) {
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleClass(Node *node, EntityContext &ctx) {
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleOtherNominalType(Node *node, EntityContext &ctx) {
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleNominalType(Node *node, char kind, EntityContext &ctx,
-                                  StringRef artificialPrivateDiscriminator) {
-  SubstitutionEntry entry;
-  if (trySubstitution(node, entry)) return;
-  mangleNamedEntity(node, kind, "", ctx, artificialPrivateDiscriminator);
-  addSubstitution(entry);
-}
-
-void Remangler::mangleBoundGenericClass(Node *node) {
-  EntityContext ctx;
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleBoundGenericStructure(Node *node) {
-  EntityContext ctx;
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleBoundGenericEnum(Node *node) {
-  EntityContext ctx;
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleBoundGenericOtherNominalType(Node *node) {
-  EntityContext ctx;
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleBoundGenericProtocol(Node *node) {
-  EntityContext ctx;
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleBoundGenericTypeAlias(Node *node) {
-  EntityContext ctx;
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleBoundGenericFunction(Node *node) {
-  EntityContext ctx;
-  // Not really a nominal type, but it works for functions, too.
-  mangleAnyNominalType(node, ctx);
-}
-
-void Remangler::mangleTypeList(Node *node) {
-  mangleChildNodes(node); // all types
-  Buffer << '_';
-}
-
-void Remangler::mangleLabelList(Node *node) {
-  if (node->getNumChildren() == 0)
-    Buffer << 'y';
-  else
-    mangleChildNodes(node);
-}
-
-void Remangler::mangleReflectionMetadataBuiltinDescriptor(Node *node) {
-  Buffer << "MRb";
-}
-
-void Remangler::mangleReflectionMetadataFieldDescriptor(Node *node) {
-  Buffer << "MRf";
-}
-
-void Remangler::mangleReflectionMetadataAssocTypeDescriptor(Node *node) {
-  Buffer << "MRa";
-}
-
-void Remangler::mangleReflectionMetadataSuperclassDescriptor(Node *node) {
-  Buffer << "MRc";
-}
-
-void Remangler::mangleGenericTypeParamDecl(Node *node) {
-  unreachable("todo");
-}
-
-void Remangler::mangleCurryThunk(Node *node) {
-  Buffer << "<curry-thunk>";
-}
-
-void Remangler::mangleDispatchThunk(Node *node) {
-  Buffer << "<dispatch-thunk>";
-}
-
-void Remangler::mangleMethodDescriptor(Node *node) {
-  Buffer << "<method-descriptor>";
-}
-
-void Remangler::mangleMethodLookupFunction(Node *node) {
-  Buffer << "<method-lookup-function>";
-}
-
-void Remangler::mangleObjCMetadataUpdateFunction(Node *node) {
-  Buffer << "<objc-metadata-update-function>";
-}
-
-void Remangler::mangleObjCResilientClassStub(Node *node) {
-  Buffer << "<objc-resilient-class-stub>";
-}
-
-void Remangler::mangleFullObjCResilientClassStub(Node *node) {
-  Buffer << "<full-objc-resilient-class-stub>";
-}
-
-void Remangler::mangleEmptyList(Node *node) {
-  Buffer << "<empty>";
-}
-
-void Remangler::mangleFirstElementMarker(Node *node) {
-  Buffer << "<first>";
-}
-
-void Remangler::mangleVariadicMarker(Node *node) {
-  // Handled in mangleTuple
-}
-
-void Remangler::mangleOutlinedCopy(Node *node) {
-  Buffer << "Wy";
-  mangleChildNodes(node);
-}
-
-void Remangler::mangleOutlinedConsume(Node *node) {
-  Buffer << "We";
-  mangleChildNodes(node);
-}
-
-void Remangler::mangleOutlinedRetain(Node *node) {
-  Buffer << "Wr";
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleOutlinedRelease(Node *node) {
-  Buffer << "Ws";
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleOutlinedInitializeWithTake(Node *node) {
-  Buffer << "Wb";
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleOutlinedInitializeWithCopy(Node *node) {
-  Buffer << "Wc";
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleOutlinedAssignWithTake(Node *node) {
-  Buffer << "Wd";
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleOutlinedAssignWithCopy(Node *node) {
-  Buffer << "Wf";
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleOutlinedDestroy(Node *node) {
-  Buffer << "Wh";
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleOutlinedVariable(Node *node) {
-  Buffer << "Tv" << node->getIndex();
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleOutlinedBridgedMethod(Node *node) {
-  Buffer << "Te" << node->getText();
-  mangleSingleChildNode(node);
-}
-
-void Remangler::mangleCoroutineContinuationPrototype(Node *node) {
-  Buffer << "TC";
-  mangleChildNodes(node);
-}
-
-void Remangler::mangleKeyPathGetterThunkHelper(Node *node) {
-  Buffer << "TK";
-  mangleChildNodes(node);
-}
-
-void Remangler::mangleKeyPathSetterThunkHelper(Node *node) {
-  Buffer << "Tk";
-  mangleChildNodes(node);
-}
-
-void Remangler::mangleKeyPathEqualsThunkHelper(Node *node) {
-  Buffer << "TH";
-  mangleChildNodes(node);
-}
-
-void Remangler::mangleKeyPathHashThunkHelper(Node *node) {
-  Buffer << "Th";
-  mangleChildNodes(node);
-}
-
-void Remangler::mangleProtocolListWithClass(Node *node) {
-  Buffer << "Xc";
-  mangleChildNode(node, 1);
-  mangleProtocolListWithoutPrefix(node->getChild(0));
-}
-
-void Remangler::mangleProtocolListWithAnyObject(Node *node) {
-  Node *P = Factory.createNode(Node::Kind::Protocol);
-  P->addChild(Factory.createNode(Node::Kind::Module, "Swift"), Factory);
-  P->addChild(Factory.createNode(Node::Kind::Identifier, "AnyObject"), Factory);
-  Buffer << "P";
-  mangleProtocolListWithoutPrefix(node->getChild(0), /*additionalProto*/ P);
-}
-
-void Remangler::mangleVTableThunk(Node *node) {
-  Buffer << "TV";
-  mangleChildNodes(node);
-}
-
-void Remangler::mangleSILBoxTypeWithLayout(Node *node) {
-  assert(node->getKind() == Node::Kind::SILBoxTypeWithLayout);
-  assert(node->getNumChildren() == 1 || node->getNumChildren() == 3);
-  Buffer << "XB";
-  auto layout = node->getChild(0);
-  assert(layout->getKind() == Node::Kind::SILBoxLayout);
-  NodePointer genericArgs = nullptr;
-  if (node->getNumChildren() == 3) {
-    NodePointer signature = node->getChild(1);
-    assert(signature->getKind() == Node::Kind::DependentGenericSignature);
-    genericArgs = node->getChild(2);
-    assert(genericArgs->getKind() == Node::Kind::TypeList);
-    
-    Buffer << 'G';
-    mangleDependentGenericSignature(signature);
-  }
-  mangleSILBoxLayout(layout);
-  if (genericArgs) {
-    for (unsigned i = 0; i < genericArgs->getNumChildren(); ++i) {
-      auto type = genericArgs->getChild(i);
-      assert(genericArgs->getKind() == Node::Kind::Type);
-      mangleType(type);
-    }
-    Buffer << '_';
-  }
-}
-
-void Remangler::mangleSILBoxLayout(Node *node) {
-  assert(node->getKind() == Node::Kind::SILBoxLayout);
-  for (unsigned i = 0; i < node->getNumChildren(); ++i) {
-    assert(node->getKind() == Node::Kind::SILBoxImmutableField
-           || node->getKind() == Node::Kind::SILBoxMutableField);
-    mangle(node->getChild(i));
-    
-  }
-  Buffer << '_';
-}
-
-void Remangler::mangleSILBoxMutableField(Node *node) {
-  Buffer << 'm';
-  assert(node->getNumChildren() == 1
-         && node->getChild(0)->getKind() == Node::Kind::Type);
-  mangleType(node->getChild(0));
-}
-
-void Remangler::mangleSILBoxImmutableField(Node *node) {
-  Buffer << 'i';
-  assert(node->getNumChildren() == 1
-         && node->getChild(0)->getKind() == Node::Kind::Type);
-  mangleType(node->getChild(0));
-}
-
-void Remangler::mangleAssocTypePath(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleModuleDescriptor(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleExtensionDescriptor(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleAnonymousDescriptor(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleAssociatedTypeGenericParamRef(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleTypeSymbolicReference(Node *node, EntityContext&) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleProtocolSymbolicReference(Node *node, EntityContext&) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleOpaqueTypeDescriptorSymbolicReference(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleSugaredOptional(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleSugaredArray(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleSugaredDictionary(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleSugaredParen(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleOpaqueReturnType(Node *node) {
-  Buffer << "Qu";
-}
-void Remangler::mangleOpaqueReturnTypeOf(Node *node, EntityContext &ctx) {
-  unreachable("unsupported");
-}
-void Remangler::mangleOpaqueType(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleOpaqueTypeDescriptor(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleOpaqueTypeDescriptorAccessor(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleOpaqueTypeDescriptorAccessorImpl(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleOpaqueTypeDescriptorAccessorKey(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleOpaqueTypeDescriptorAccessorVar(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleAccessorFunctionReference(Node *node) {
-  unreachable("can't remangle");
-}
-void Remangler::mangleMetadataInstantiationCache(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleGlobalVariableOnceToken(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleGlobalVariableOnceFunction(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleGlobalVariableOnceDeclList(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::manglePredefinedObjCAsyncCompletionHandlerImpl(Node *node) {
-  unreachable("unsupported");
-}
-void Remangler::mangleObjCAsyncCompletionHandlerImpl(Node *node) {
-  unreachable("unsupported");
-}
-
-void Remangler::mangleCanonicalSpecializedGenericMetaclass(Node *node) {
-  mangleSingleChildNode(node); // type
-  Buffer << "MM";
-}
-
-void Remangler::mangleCanonicalSpecializedGenericTypeMetadataAccessFunction(
-    Node *node) {
-  mangleSingleChildNode(node);
-  Buffer << "Mb";
-}
-
-void Remangler::mangleNoncanonicalSpecializedGenericTypeMetadata(Node *node) {
-  mangleSingleChildNode(node);
-  Buffer << "MN";
-}
-
-void Remangler::mangleNoncanonicalSpecializedGenericTypeMetadataCache(Node *node) {
-  mangleSingleChildNode(node);
-  Buffer << "MJ";
-}
-
-void Remangler::mangleCanonicalPrespecializedGenericTypeCachingOnceToken(
-    Node *node) {
-  mangleSingleChildNode(node);
-  Buffer << "Mz";
-}
-
-/// The top-level interface to the remangler.
-std::string Demangle::mangleNodeOld(NodePointer node) {
-  if (!node) return "";
-
-  NodeFactory Factory;
-  Remangler remangler(Factory);
-  remangler.mangle(node);
-
-  return remangler.str();
-}
-
-llvm::StringRef Demangle::mangleNodeOld(NodePointer node, NodeFactory &Factory) {
-  if (!node) return "";
-
-  Remangler remangler(Factory);
-  remangler.mangle(node);
-
-  return remangler.getBufferStr();
-}
-
-const char *Demangle::mangleNodeAsObjcCString(NodePointer node,
-                                              NodeFactory &Factory) {
-  assert(node);
-
-  Remangler remangler(Factory);
-  remangler.append("_Tt");
-  remangler.mangle(node);
-  remangler.append(StringRef("_", 2)); // Include the trailing 0 char.
-
-  return remangler.getBufferStr().data();
-}
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/Remangler.cpp b/symbolic-demangle/vendor/swift/lib/Demangling/Remangler.cpp
index b743fd4f9..be1bca1d7 100644
--- a/symbolic-demangle/vendor/swift/lib/Demangling/Remangler.cpp
+++ b/symbolic-demangle/vendor/swift/lib/Demangling/Remangler.cpp
@@ -16,15 +16,16 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "DemanglerAssert.h"
+#include "RemanglerBase.h"
+#include "swift/AST/Ownership.h"
 #include "swift/Demangling/Demangler.h"
-#include "swift/Demangling/Punycode.h"
-#include "swift/Demangling/ManglingUtils.h"
 #include "swift/Demangling/ManglingMacros.h"
-#include "swift/AST/Ownership.h"
+#include "swift/Demangling/ManglingUtils.h"
+#include "swift/Demangling/Punycode.h"
 #include "swift/Strings.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
-#include "RemanglerBase.h"
 #include <cstdio>
 #include <cstdlib>
 
@@ -32,12 +33,6 @@ using namespace swift;
 using namespace Demangle;
 using namespace Mangle;
 
-[[noreturn]]
-static void unreachable(const char *Message) {
-  fprintf(stderr, "fatal error: %s\n", Message);
-  std::abort();
-}
-
 static char getCharOfNodeText(Node *node, unsigned idx) {
   switch (node->getKind()) {
   case Node::Kind::InfixOperator:
@@ -64,63 +59,115 @@ bool SubstitutionEntry::identifierEquals(Node *lhs, Node *rhs) {
   return true;
 }
 
-void SubstitutionEntry::deepHash(Node *node) {
+bool SubstitutionEntry::deepEquals(Node *lhs, Node *rhs) const {
+  if (!lhs->isSimilarTo(rhs))
+    return false;
+
+  for (auto li = lhs->begin(), ri = rhs->begin(), le = lhs->end();
+       li != le; ++li, ++ri) {
+    if (!deepEquals(*li, *ri))
+      return false;
+  }
+
+  return true;
+}
+
+static inline size_t combineHash(size_t currentHash, size_t newValue) {
+  return 33 * currentHash + newValue;
+}
+
+/// Calculate the hash for a node.
+size_t RemanglerBase::hashForNode(Node *node,
+                                  bool treatAsIdentifier) {
+  size_t hash = 0;
+
   if (treatAsIdentifier) {
-    combineHash((size_t) Node::Kind::Identifier);
+    hash = combineHash(hash, (size_t)Node::Kind::Identifier);
     assert(node->hasText());
     switch (node->getKind()) {
     case Node::Kind::InfixOperator:
     case Node::Kind::PrefixOperator:
     case Node::Kind::PostfixOperator:
       for (char c : node->getText()) {
-        combineHash((unsigned char)translateOperatorChar(c));
+        hash = combineHash(hash, (unsigned char)translateOperatorChar(c));
       }
-      return;
+      return hash;
     default:
       break;
     }
   } else {
-    combineHash((size_t) node->getKind());
+    hash = combineHash(hash, (size_t) node->getKind());
   }
   if (node->hasIndex()) {
-    combineHash(node->getIndex());
+    hash = combineHash(hash, node->getIndex());
   } else if (node->hasText()) {
     for (char c : node->getText()) {
-      combineHash((unsigned char) c);
+      hash = combineHash(hash, (unsigned char) c);
     }
   }
   for (Node *child : *node) {
-    deepHash(child);
+    SubstitutionEntry entry = entryForNode(child, treatAsIdentifier);
+    hash = combineHash(hash, entry.hash());
   }
+
+  return hash;
 }
 
-bool SubstitutionEntry::deepEquals(Node *lhs, Node *rhs) const {
-  if (lhs->getKind() != rhs->getKind())
-    return false;
-  if (lhs->hasIndex()) {
-    if (!rhs->hasIndex())
-      return false;
-    if (lhs->getIndex() != rhs->getIndex())
-      return false;
-  } else if (lhs->hasText()) {
-    if (!rhs->hasText())
-      return false;
-    if (lhs->getText() != rhs->getText())
-      return false;
-  } else if (rhs->hasIndex() || rhs->hasText()) {
-    return false;
-  }
+/// Rotate a size_t by N bits
+static inline size_t rotate(size_t value, size_t shift) {
+  const size_t bits = sizeof(size_t) * 8;
+  return (value >> shift) | (value << (bits - shift));
+}
 
-  if (lhs->getNumChildren() != rhs->getNumChildren())
-    return false;
+/// Compute a hash value from a node *pointer*.
+/// Used for look-ups in HashHash.  The numbers in here were determined
+/// experimentally.
+static inline size_t nodeHash(Node *node) {
+  // Multiply by a magic number
+  const size_t nodePrime = ((size_t)node) * 2043;
 
-  for (auto li = lhs->begin(), ri = rhs->begin(), le = lhs->end();
-       li != le; ++li, ++ri) {
-    if (!deepEquals(*li, *ri))
-      return false;
+  // We rotate by a different amount because the alignment of Node
+  // changes depending on the machine's pointer size
+  switch (sizeof(size_t)) {
+  case 4:
+    return rotate(nodePrime, 11);
+  case 8:
+    return rotate(nodePrime, 12);
+  case 16:
+    return rotate(nodePrime, 13);
+  default:
+    return rotate(nodePrime, 12);
   }
-  
-  return true;
+}
+
+/// Construct a SubstitutionEntry for a given node.
+/// This will look in the HashHash to see if we already know the hash
+/// (which avoids recursive hashing on the Node tree).
+SubstitutionEntry RemanglerBase::entryForNode(Node *node,
+                                              bool treatAsIdentifier) {
+  const size_t ident = treatAsIdentifier ? 4 : 0;
+  const size_t hash = nodeHash(node) + ident;
+
+  // Use linear probing with a limit
+  for (size_t n = 0; n < HashHashMaxProbes; ++n) {
+    const size_t ndx = (hash + n) & (HashHashCapacity - 1);
+    SubstitutionEntry entry = HashHash[ndx];
+
+    if (entry.isEmpty()) {
+      size_t entryHash = hashForNode(node, treatAsIdentifier);
+      entry.setNode(node, treatAsIdentifier, entryHash);
+      HashHash[ndx] = entry;
+      return entry;
+    } else if (entry.matches(node, treatAsIdentifier)) {
+      return entry;
+    }
+  }
+
+  // Hash table is full at this hash value
+  SubstitutionEntry entry;
+  size_t entryHash = hashForNode(node, treatAsIdentifier);
+  entry.setNode(node, treatAsIdentifier, entryHash);
+  return entry;
 }
 
 // Find a substitution and return its index.
@@ -170,6 +217,8 @@ class Remangler : public RemanglerBase {
 
   static const size_t MaxNumWords = 26;
 
+  static const unsigned MaxDepth = 1024;
+
   SubstitutionMerging SubstMerging;
 
   // A callback for resolving symbolic references.
@@ -204,6 +253,7 @@ class Remangler : public RemanglerBase {
     };
   };
 
+  // ###TODO: Consider fixing some of these asserts() to return errors somehow
   Node *getSingleChild(Node *node) {
     assert(node->getNumChildren() == 1);
     return node->getFirstChild();
@@ -226,6 +276,7 @@ class Remangler : public RemanglerBase {
     return getSingleChild(node);
   }
 
+  // Cannot fail
   void mangleIndex(Node::IndexType value) {
     if (value == 0) {
       Buffer << '_';
@@ -233,15 +284,16 @@ class Remangler : public RemanglerBase {
       Buffer << (value - 1) << '_';
     }
   }
-  void mangleDependentConformanceIndex(Node *node);
+  ManglingError mangleDependentConformanceIndex(Node *node, unsigned depth);
 
-  void mangleChildNodes(Node *node) {
-    mangleNodes(node->begin(), node->end());
+  ManglingError mangleChildNodes(Node *node, unsigned depth) {
+    return mangleNodes(node->begin(), node->end(), depth);
   }
-  void mangleChildNodesReversed(Node *node) {
+  ManglingError mangleChildNodesReversed(Node *node, unsigned depth) {
     for (size_t Idx = 0, Num = node->getNumChildren(); Idx < Num; ++Idx) {
-      mangleChildNode(node, Num - Idx - 1);
+      RETURN_IF_ERROR(mangleChildNode(node, Num - Idx - 1, depth));
     }
+    return ManglingError::Success;
   }
 
   void mangleListSeparator(bool &isFirstListItem) {
@@ -256,32 +308,36 @@ class Remangler : public RemanglerBase {
       Buffer << 'y';
   }
 
-  void mangleNodes(Node::iterator i, Node::iterator e) {
+  ManglingError mangleNodes(Node::iterator i, Node::iterator e,
+                            unsigned depth) {
     for (; i != e; ++i) {
-      mangle(*i);
+      RETURN_IF_ERROR(mangle(*i, depth));
     }
+    return ManglingError::Success;
   }
 
-  void mangleSingleChildNode(Node *node) {
-    assert(node->getNumChildren() == 1);
-    mangle(*node->begin());
+  ManglingError mangleSingleChildNode(Node *node, unsigned depth) {
+    if (node->getNumChildren() != 1)
+      return MANGLING_ERROR(ManglingError::MultipleChildNodes, node);
+    return mangle(*node->begin(), depth);
   }
 
-  void mangleChildNode(Node *node, unsigned index) {
+  ManglingError mangleChildNode(Node *node, unsigned index, unsigned depth) {
     if (index < node->getNumChildren())
-      mangle(node->begin()[index]);
+      return mangle(node->begin()[index], depth);
+    return ManglingError::Success;
   }
 
-  void manglePureProtocol(Node *Proto) {
+  ManglingError manglePureProtocol(Node *Proto, unsigned depth) {
     Proto = skipType(Proto);
     if (mangleStandardSubstitution(Proto))
-      return;
-    
-    mangleChildNodes(Proto);
+      return ManglingError::Success;
+
+    return mangleChildNodes(Proto, depth);
   }
 
-  void mangleProtocolList(Node *protocols, Node *superclass,
-                          bool hasExplicitAnyObject);
+  ManglingError mangleProtocolList(Node *protocols, Node *superclass,
+                                   bool hasExplicitAnyObject, unsigned depth);
 
   bool trySubstitution(Node *node, SubstitutionEntry &entry,
                        bool treatAsIdentifier = false);
@@ -290,46 +346,59 @@ class Remangler : public RemanglerBase {
 
   bool mangleStandardSubstitution(Node *node);
 
+  // Cannot fail
   void mangleDependentGenericParamIndex(Node *node,
                                         const char *nonZeroPrefix = "",
                                         char zeroOp = 'z');
 
-  std::pair<int, Node *> mangleConstrainedType(Node *node);
+  ManglingErrorOr<std::pair<int, Node *>> mangleConstrainedType(Node *node,
+                                                                unsigned depth);
 
-  void mangleFunctionSignature(Node *FuncType) {
-    mangleChildNodesReversed(FuncType);
+  ManglingError mangleFunctionSignature(Node *FuncType, unsigned depth) {
+    return mangleChildNodesReversed(FuncType, depth);
   }
 
-  void mangleGenericSpecializationNode(Node *node, const char *operatorStr);
-  void mangleAnyNominalType(Node *node);
-  void mangleAnyGenericType(Node *node, StringRef TypeOp);
-  void mangleGenericArgs(Node *node, char &Separator,
-                         bool fullSubstitutionMap=false);
-  void mangleAnyConstructor(Node *node, char kindOp);
-  void mangleAbstractStorage(Node *node, StringRef accessorCode);
-  void mangleAnyProtocolConformance(Node *node);
-
-  void mangleKeyPathThunkHelper(Node *node, StringRef op);
-
-  void mangleAutoDiffFunctionOrSimpleThunk(Node *node, StringRef op);
-
-#define NODE(ID)                                                        \
-  void mangle##ID(Node *node);
-#define CONTEXT_NODE(ID)                                                \
-  void mangle##ID(Node *node);                                        \
-//    void mangle##ID(Node *node, EntityContext &ctx);
+  ManglingError mangleGenericSpecializationNode(Node *node,
+                                                const char *operatorStr,
+                                                unsigned depth);
+  ManglingError mangleAnyNominalType(Node *node, unsigned depth);
+  ManglingError mangleAnyGenericType(Node *node, StringRef TypeOp,
+                                     unsigned depth);
+  ManglingError mangleGenericArgs(Node *node, char &Separator, unsigned depth,
+                                  bool fullSubstitutionMap = false);
+  ManglingError mangleAnyConstructor(Node *node, char kindOp, unsigned depth);
+  ManglingError mangleAbstractStorage(Node *node, StringRef accessorCode,
+                                      unsigned depth);
+  ManglingError mangleAnyProtocolConformance(Node *node, unsigned depth);
+
+  ManglingError mangleKeyPathThunkHelper(Node *node, StringRef op,
+                                         unsigned depth);
+
+  ManglingError mangleAutoDiffFunctionOrSimpleThunk(Node *node, StringRef op,
+                                                    unsigned depth);
+
+#define NODE(ID) ManglingError mangle##ID(Node *node, unsigned depth);
+#define CONTEXT_NODE(ID)                                                       \
+  ManglingError mangle##ID(Node *node, unsigned depth);                        \
+//    ManglingError mangle##ID(Node *node, unsigned depth, EntityContext &ctx);
 #include "swift/Demangling/DemangleNodes.def"
 
 public:
   Remangler(SymbolicResolver Resolver, NodeFactory &Factory)
        : RemanglerBase(Factory), Resolver(Resolver) { }
 
-  void mangle(Node *node) {
+  ManglingError mangle(Node *node, unsigned depth) {
+    if (depth > Remangler::MaxDepth) {
+      return MANGLING_ERROR(ManglingError::TooComplex, node);
+    }
+
     switch (node->getKind()) {
-#define NODE(ID) case Node::Kind::ID: return mangle##ID(node);
+#define NODE(ID)                                                               \
+  case Node::Kind::ID:                                                         \
+    return mangle##ID(node, depth);
 #include "swift/Demangling/DemangleNodes.def"
     }
-    unreachable("bad demangling tree node");
+    return MANGLING_ERROR(ManglingError::BadNodeKind, node);
   }
 };
 
@@ -339,7 +408,7 @@ bool Remangler::trySubstitution(Node *node, SubstitutionEntry &entry,
     return true;
 
   // Go ahead and initialize the substitution entry.
-  entry.setNode(node, treatAsIdentifier);
+  entry = entryForNode(node, treatAsIdentifier);
 
   int Idx = findSubstitution(entry);
   if (Idx < 0)
@@ -386,7 +455,8 @@ bool Remangler::mangleStandardSubstitution(Node *node) {
   if (node->getChild(1)->getKind() != Node::Kind::Identifier)
     return false;
 
-  if (auto Subst = getStandardTypeSubst(node->getChild(1)->getText())) {
+  if (auto Subst = getStandardTypeSubst(
+          node->getChild(1)->getText(), /*allowConcurrencyManglings=*/true)) {
     if (!SubstMerging.tryMergeSubst(*this, *Subst, /*isStandardSubst*/ true)) {
       Buffer << 'S' << *Subst;
     }
@@ -396,14 +466,19 @@ bool Remangler::mangleStandardSubstitution(Node *node) {
 }
 
 void Remangler::mangleDependentGenericParamIndex(Node *node,
-                                                    const char *nonZeroPrefix,
-                                                    char zeroOp) {
-  auto depth = node->getChild(0)->getIndex();
+                                                 const char *nonZeroPrefix,
+                                                 char zeroOp) {
+  if (node->getKind() == Node::Kind::ConstrainedExistentialSelf) {
+    Buffer << 's';
+    return;
+  }
+
+  auto paramDepth = node->getChild(0)->getIndex();
   auto index = node->getChild(1)->getIndex();
 
-  if (depth != 0) {
+  if (paramDepth != 0) {
     Buffer << nonZeroPrefix << 'd';
-    mangleIndex(depth - 1);
+    mangleIndex(paramDepth - 1);
     mangleIndex(index);
     return;
   }
@@ -416,81 +491,103 @@ void Remangler::mangleDependentGenericParamIndex(Node *node,
   Buffer << zeroOp;
 }
 
-std::pair<int, Node *> Remangler::mangleConstrainedType(Node *node) {
+ManglingErrorOr<std::pair<int, Node *>>
+Remangler::mangleConstrainedType(Node *node, unsigned depth) {
   if (node->getKind() == Node::Kind::Type)
     node = getChildOfType(node);
 
   SubstitutionEntry entry;
   if (trySubstitution(node, entry))
-    return {-1, nullptr};
+    return std::pair<int, Node *>{-1, nullptr};
 
   Vector<Node *> Chain;
   while (node->getKind() == Node::Kind::DependentMemberType) {
     Chain.push_back(node->getChild(1), Factory);
     node = getChildOfType(node->getFirstChild());
   }
-  
-  if (node->getKind() != Node::Kind::DependentGenericParamType) {
-    mangle(node);
+
+  if (node->getKind() != Node::Kind::DependentGenericParamType &&
+      node->getKind() != Node::Kind::ConstrainedExistentialSelf) {
+    RETURN_IF_ERROR(mangle(node, depth + 1));
+    if (!Chain.size())
+      return std::pair<int, Node *>{-1, nullptr};
     node = nullptr;
   }
 
   const char *ListSeparator = (Chain.size() > 1 ? "_" : "");
   for (unsigned i = 1, n = Chain.size(); i <= n; ++i) {
     Node *DepAssocTyRef = Chain[n - i];
-    mangle(DepAssocTyRef);
+    RETURN_IF_ERROR(mangle(DepAssocTyRef, depth + 1));
     Buffer << ListSeparator;
     ListSeparator = "";
   }
   if (!Chain.empty())
     addSubstitution(entry);
-  return {(int)Chain.size(), node};
+  return std::pair<int, Node *>{(int)Chain.size(), node};
 }
 
-void Remangler::mangleAnyGenericType(Node *node, StringRef TypeOp) {
+ManglingError Remangler::mangleAnyGenericType(Node *node, StringRef TypeOp,
+                                              unsigned depth) {
   SubstitutionEntry entry;
-  if (trySubstitution(node, entry)) return;
-  mangleChildNodes(node);
-  Buffer << TypeOp;
-  addSubstitution(entry);
+  if (!trySubstitution(node, entry)) {
+    RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
+    Buffer << TypeOp;
+    addSubstitution(entry);
+  }
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAnyNominalType(Node *node) {
+ManglingError Remangler::mangleAnyNominalType(Node *node, unsigned depth) {
+  if (depth > Remangler::MaxDepth) {
+    return MANGLING_ERROR(ManglingError::TooComplex, node);
+  }
+
   if (isSpecialized(node)) {
     SubstitutionEntry entry;
     if (trySubstitution(node, entry))
-      return;
+      return ManglingError::Success;
 
-    NodePointer unboundType = getUnspecialized(node, Factory);
-    mangleAnyNominalType(unboundType);
+    auto unspec = getUnspecialized(node, Factory);
+    if (!unspec.isSuccess())
+      return unspec.error();
+    NodePointer unboundType = unspec.result();
+    RETURN_IF_ERROR(mangleAnyNominalType(unboundType, depth + 1));
     char Separator = 'y';
-    mangleGenericArgs(node, Separator);
+    RETURN_IF_ERROR(mangleGenericArgs(node, Separator, depth + 1));
 
     if (node->getNumChildren() == 3) {
       // Retroactive conformances.
       auto listNode = node->getChild(2);
       for (size_t Idx = 0, Num = listNode->getNumChildren(); Idx < Num; ++Idx) {
-        mangle(listNode->getChild(Idx));
+        RETURN_IF_ERROR(mangle(listNode->getChild(Idx), depth + 1));
       }
     }
 
     Buffer << 'G';
     addSubstitution(entry);
-    return;
+    return ManglingError::Success;
   }
   switch (node->getKind()) {
-    case Node::Kind::Structure: return mangleAnyGenericType(node, "V");
-    case Node::Kind::Enum: return mangleAnyGenericType(node, "O");
-    case Node::Kind::Class: return mangleAnyGenericType(node, "C");
-    case Node::Kind::OtherNominalType: return mangleAnyGenericType(node, "XY");
-    case Node::Kind::TypeAlias: return mangleAnyGenericType(node, "a");
-    default:
-      unreachable("bad nominal type kind");
+  case Node::Kind::Structure:
+    return mangleAnyGenericType(node, "V", depth);
+  case Node::Kind::Enum:
+    return mangleAnyGenericType(node, "O", depth);
+  case Node::Kind::Class:
+    return mangleAnyGenericType(node, "C", depth);
+  case Node::Kind::OtherNominalType:
+    return mangleAnyGenericType(node, "XY", depth);
+  case Node::Kind::TypeAlias:
+    return mangleAnyGenericType(node, "a", depth);
+  case Node::Kind::TypeSymbolicReference:
+    return mangleTypeSymbolicReference(node, depth);
+  default:
+    return MANGLING_ERROR(ManglingError::BadNominalTypeKind, node);
   }
 }
 
-void Remangler::mangleGenericArgs(Node *node, char &Separator,
-                                  bool fullSubstitutionMap) {
+ManglingError Remangler::mangleGenericArgs(Node *node, char &Separator,
+                                           unsigned depth,
+                                           bool fullSubstitutionMap) {
   switch (node->getKind()) {
     case Node::Kind::Protocol:
       // A protocol cannot be the parent of a nominal type, so this case should
@@ -505,8 +602,8 @@ void Remangler::mangleGenericArgs(Node *node, char &Separator,
       if (node->getKind() == Node::Kind::TypeAlias)
         fullSubstitutionMap = true;
 
-      mangleGenericArgs(node->getChild(0), Separator,
-                        fullSubstitutionMap);
+      RETURN_IF_ERROR(mangleGenericArgs(node->getChild(0), Separator, depth + 1,
+                                        fullSubstitutionMap));
       Buffer << Separator;
       Separator = '_';
       break;
@@ -531,11 +628,12 @@ void Remangler::mangleGenericArgs(Node *node, char &Separator,
     case Node::Kind::Initializer:
     case Node::Kind::PropertyWrapperBackingInitializer:
     case Node::Kind::PropertyWrapperInitFromProjectedValue:
+    case Node::Kind::Static:
       if (!fullSubstitutionMap)
         break;
 
-      mangleGenericArgs(node->getChild(0), Separator,
-                        fullSubstitutionMap);
+      RETURN_IF_ERROR(mangleGenericArgs(node->getChild(0), Separator, depth + 1,
+                                        fullSubstitutionMap));
       if (Demangle::nodeConsumesGenericArgs(node)) {
         Buffer << Separator;
         Separator = '_';
@@ -552,190 +650,251 @@ void Remangler::mangleGenericArgs(Node *node, char &Separator,
         fullSubstitutionMap = true;
 
       NodePointer unboundType = node->getChild(0);
-      assert(unboundType->getKind() == Node::Kind::Type);
+      DEMANGLER_ASSERT(unboundType->getKind() == Node::Kind::Type, node);
       NodePointer nominalType = unboundType->getChild(0);
+      if (nominalType->getKind() == Node::Kind::TypeSymbolicReference) {
+          NodePointer resolvedUnboundType = Resolver(SymbolicReferenceKind::Context, (const void *)nominalType->getIndex());
+          nominalType = resolvedUnboundType->getChild(0);
+      }
       NodePointer parentOrModule = nominalType->getChild(0);
-      mangleGenericArgs(parentOrModule, Separator,
-                        fullSubstitutionMap);
+      RETURN_IF_ERROR(mangleGenericArgs(parentOrModule, Separator, depth + 1,
+                                        fullSubstitutionMap));
       Buffer << Separator;
       Separator = '_';
-      mangleChildNodes(node->getChild(1));
+      RETURN_IF_ERROR(mangleChildNodes(node->getChild(1), depth + 1));
       break;
     }
-      
+
+    case Node::Kind::ConstrainedExistential: {
+      Buffer << Separator;
+      Separator = '_';
+      RETURN_IF_ERROR(mangleChildNodes(node->getChild(1), depth + 1));
+      break;
+    }
+
     case Node::Kind::BoundGenericFunction: {
       fullSubstitutionMap = true;
 
       NodePointer unboundFunction = node->getChild(0);
-      assert(unboundFunction->getKind() == Node::Kind::Function ||
-             unboundFunction->getKind() == Node::Kind::Constructor);
+      DEMANGLER_ASSERT(unboundFunction->getKind() == Node::Kind::Function ||
+                           unboundFunction->getKind() ==
+                               Node::Kind::Constructor,
+                       node);
       NodePointer parentOrModule = unboundFunction->getChild(0);
-      mangleGenericArgs(parentOrModule, Separator,
-                        fullSubstitutionMap);
+      RETURN_IF_ERROR(mangleGenericArgs(parentOrModule, Separator, depth + 1,
+                                        fullSubstitutionMap));
       Buffer << Separator;
       Separator = '_';
-      mangleChildNodes(node->getChild(1));
+      RETURN_IF_ERROR(mangleChildNodes(node->getChild(1), depth + 1));
       break;
     }
 
     case Node::Kind::Extension:
-      mangleGenericArgs(node->getChild(1), Separator,
-                        fullSubstitutionMap);
+      RETURN_IF_ERROR(mangleGenericArgs(node->getChild(1), Separator, depth + 1,
+                                        fullSubstitutionMap));
       break;
 
     default:
       break;
   }
+
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAbstractStorage(Node *node, StringRef accessorCode) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleAbstractStorage(Node *node,
+                                               StringRef accessorCode,
+                                               unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   switch (node->getKind()) {
     case Node::Kind::Subscript: Buffer << "i"; break;
     case Node::Kind::Variable: Buffer << "v"; break;
-    default: unreachable("Not a storage node");
+    default:
+      return MANGLING_ERROR(ManglingError::NotAStorageNode, node);
   }
   Buffer << accessorCode;
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAllocator(Node *node) {
-  mangleAnyConstructor(node, 'C');
+ManglingError Remangler::mangleAllocator(Node *node, unsigned depth) {
+  return mangleAnyConstructor(node, 'C', depth + 1);
 }
 
-void Remangler::mangleArgumentTuple(Node *node) {
+ManglingError Remangler::mangleArgumentTuple(Node *node, unsigned depth) {
   Node *Child = skipType(getSingleChild(node));
   if (Child->getKind() == Node::Kind::Tuple &&
       Child->getNumChildren() == 0) {
     Buffer << 'y';
-    return;
+    return ManglingError::Success;
   }
-  mangle(Child);
+  return mangle(Child, depth + 1);
 }
 
-void Remangler::mangleAssociatedType(Node *node) {
-  unreachable("unsupported node");
+ManglingError Remangler::mangleAssociatedType(Node *node, unsigned depth) {
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleAssociatedTypeRef(Node *node) {
+ManglingError Remangler::mangleAssociatedTypeRef(Node *node, unsigned depth) {
   SubstitutionEntry entry;
-  if (trySubstitution(node, entry)) return;
-  mangleChildNodes(node);
+  if (trySubstitution(node, entry))
+    return ManglingError::Success;
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "Qa";
   addSubstitution(entry);
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAssociatedTypeDescriptor(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleAssociatedTypeDescriptor(Node *node,
+                                                        unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "Tl";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAssociatedConformanceDescriptor(Node *node) {
-  mangle(node->getChild(0));
-  mangle(node->getChild(1));
-  manglePureProtocol(node->getChild(2));
+ManglingError Remangler::mangleAssociatedConformanceDescriptor(Node *node,
+                                                               unsigned depth) {
+  RETURN_IF_ERROR(mangle(node->getChild(0), depth + 1));
+  RETURN_IF_ERROR(mangle(node->getChild(1), depth + 1));
+  RETURN_IF_ERROR(manglePureProtocol(node->getChild(2), depth + 1));
   Buffer << "Tn";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDefaultAssociatedConformanceAccessor(Node *node) {
-  mangle(node->getChild(0));
-  mangle(node->getChild(1));
-  manglePureProtocol(node->getChild(2));
+ManglingError
+Remangler::mangleDefaultAssociatedConformanceAccessor(Node *node,
+                                                      unsigned depth) {
+  RETURN_IF_ERROR(mangle(node->getChild(0), depth + 1));
+  RETURN_IF_ERROR(mangle(node->getChild(1), depth + 1));
+  RETURN_IF_ERROR(manglePureProtocol(node->getChild(2), depth + 1));
   Buffer << "TN";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleBaseConformanceDescriptor(Node *node) {
-  mangle(node->getChild(0));
-  manglePureProtocol(node->getChild(1));
+ManglingError Remangler::mangleBaseConformanceDescriptor(Node *node,
+                                                         unsigned depth) {
+  RETURN_IF_ERROR(mangle(node->getChild(0), depth + 1));
+  RETURN_IF_ERROR(manglePureProtocol(node->getChild(1), depth + 1));
   Buffer << "Tb";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAssociatedTypeMetadataAccessor(Node *node) {
-  mangleChildNodes(node); // protocol conformance, identifier
+ManglingError Remangler::mangleAssociatedTypeMetadataAccessor(Node *node,
+                                                              unsigned depth) {
+  RETURN_IF_ERROR(
+      mangleChildNodes(node, depth + 1)); // protocol conformance, identifier
   Buffer << "Wt";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDefaultAssociatedTypeMetadataAccessor(Node *node) {
-  mangleChildNodes(node); // protocol conformance, identifier
+ManglingError
+Remangler::mangleDefaultAssociatedTypeMetadataAccessor(Node *node,
+                                                       unsigned depth) {
+  RETURN_IF_ERROR(
+      mangleChildNodes(node, depth + 1)); // protocol conformance, identifier
   Buffer << "TM";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAssociatedTypeWitnessTableAccessor(Node *node) {
-  mangleChildNodes(node); // protocol conformance, type, protocol
+ManglingError
+Remangler::mangleAssociatedTypeWitnessTableAccessor(Node *node,
+                                                    unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(
+      node, depth + 1)); // protocol conformance, type, protocol
   Buffer << "WT";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleBaseWitnessTableAccessor(Node *node) {
-  mangleChildNodes(node); // protocol conformance, protocol
+ManglingError Remangler::mangleBaseWitnessTableAccessor(Node *node,
+                                                        unsigned depth) {
+  RETURN_IF_ERROR(
+      mangleChildNodes(node, depth + 1)); // protocol conformance, protocol
   Buffer << "Wb";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAutoClosureType(Node *node) {
-  mangleChildNodesReversed(node); // argument tuple, result type
+ManglingError Remangler::mangleAutoClosureType(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(
+      mangleChildNodesReversed(node, depth + 1)); // argument tuple, result type
   Buffer << "XK";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleEscapingAutoClosureType(Node *node) {
-  mangleChildNodesReversed(node); // argument tuple, result type
+ManglingError Remangler::mangleEscapingAutoClosureType(Node *node,
+                                                       unsigned depth) {
+  RETURN_IF_ERROR(
+      mangleChildNodesReversed(node, depth + 1)); // argument tuple, result type
   Buffer << "XA";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleNoEscapeFunctionType(Node *node) {
-  mangleChildNodesReversed(node); // argument tuple, result type
+ManglingError Remangler::mangleNoEscapeFunctionType(Node *node,
+                                                    unsigned depth) {
+  RETURN_IF_ERROR(
+      mangleChildNodesReversed(node, depth + 1)); // argument tuple, result type
   Buffer << "XE";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleBoundGenericClass(Node *node) {
-  mangleAnyNominalType(node);
+ManglingError Remangler::mangleBoundGenericClass(Node *node, unsigned depth) {
+  return mangleAnyNominalType(node, depth + 1);
 }
 
-void Remangler::mangleBoundGenericEnum(Node *node) {
+ManglingError Remangler::mangleBoundGenericEnum(Node *node, unsigned depth) {
   Node *Enum = node->getChild(0)->getChild(0);
-  assert(Enum->getKind() == Node::Kind::Enum);
+  DEMANGLER_ASSERT(Enum->getKind() == Node::Kind::Enum, node);
   Node *Mod = Enum->getChild(0);
   Node *Id = Enum->getChild(1);
   if (Mod->getKind() == Node::Kind::Module && Mod->getText() == STDLIB_NAME &&
       Id->getKind() == Node::Kind::Identifier && Id->getText() == "Optional") {
     SubstitutionEntry entry;
     if (trySubstitution(node, entry))
-      return;
-    mangleSingleChildNode(node->getChild(1));
+      return ManglingError::Success;
+    RETURN_IF_ERROR(mangleSingleChildNode(node->getChild(1), depth + 1));
     Buffer << "Sg";
     addSubstitution(entry);
-    return;
+    return ManglingError::Success;
   }
-  mangleAnyNominalType(node);
+  return mangleAnyNominalType(node, depth + 1);
 }
 
-void Remangler::mangleBoundGenericStructure(Node *node) {
-  mangleAnyNominalType(node);
+ManglingError Remangler::mangleBoundGenericStructure(Node *node,
+                                                     unsigned depth) {
+  return mangleAnyNominalType(node, depth + 1);
 }
 
-void Remangler::mangleBoundGenericOtherNominalType(Node *node) {
-  mangleAnyNominalType(node);
+ManglingError Remangler::mangleBoundGenericOtherNominalType(Node *node,
+                                                            unsigned depth) {
+  return mangleAnyNominalType(node, depth + 1);
 }
 
-void Remangler::mangleBoundGenericProtocol(Node *node) {
-  mangleAnyNominalType(node);
+ManglingError Remangler::mangleBoundGenericProtocol(Node *node,
+                                                    unsigned depth) {
+  return mangleAnyNominalType(node, depth + 1);
 }
 
-void Remangler::mangleBoundGenericTypeAlias(Node *node) {
-  mangleAnyNominalType(node);
+ManglingError Remangler::mangleBoundGenericTypeAlias(Node *node,
+                                                     unsigned depth) {
+  return mangleAnyNominalType(node, depth + 1);
 }
 
-void Remangler::mangleBoundGenericFunction(Node *node) {
+ManglingError Remangler::mangleBoundGenericFunction(Node *node,
+                                                    unsigned depth) {
   SubstitutionEntry entry;
   if (trySubstitution(node, entry))
-    return;
+    return ManglingError::Success;
 
-  NodePointer unboundFunction = getUnspecialized(node, Factory);
-  mangleFunction(unboundFunction);
+  auto unspec = getUnspecialized(node, Factory);
+  if (!unspec.isSuccess())
+    return unspec.error();
+  NodePointer unboundFunction = unspec.result();
+  RETURN_IF_ERROR(mangleFunction(unboundFunction, depth + 1));
   char Separator = 'y';
-  mangleGenericArgs(node, Separator);
+  RETURN_IF_ERROR(mangleGenericArgs(node, Separator, depth + 1));
   Buffer << 'G';
   addSubstitution(entry);
+  return ManglingError::Success;
 }
 
-void Remangler::mangleBuiltinTypeName(Node *node) {
+ManglingError Remangler::mangleBuiltinTypeName(Node *node, unsigned depth) {
   Buffer << 'B';
   StringRef text = node->getText();
 
@@ -755,6 +914,8 @@ void Remangler::mangleBuiltinTypeName(Node *node) {
     Buffer << 'j';
   } else if (text == BUILTIN_TYPE_NAME_DEFAULTACTORSTORAGE) {
     Buffer << 'D';
+  } else if (text == BUILTIN_TYPE_NAME_NONDEFAULTDISTRIBUTEDACTORSTORAGE) {
+    Buffer << 'd';
   } else if (text == BUILTIN_TYPE_NAME_EXECUTOR) {
     Buffer << 'e';
   } else if (text == BUILTIN_TYPE_NAME_SILTOKEN) {
@@ -763,6 +924,8 @@ void Remangler::mangleBuiltinTypeName(Node *node) {
     Buffer << 'I';
   } else if (text == BUILTIN_TYPE_NAME_WORD) {
     Buffer << 'w';
+  } else if (text == BUILTIN_TYPE_NAME_PACKINDEX) {
+    Buffer << 'P';
   } else if (text.consume_front(BUILTIN_TYPE_NAME_INT)) {
     Buffer << 'i' << text << '_';
   } else if (text.consume_front(BUILTIN_TYPE_NAME_FLOAT)) {
@@ -779,143 +942,272 @@ void Remangler::mangleBuiltinTypeName(Node *node) {
     } else if (element.consume_front("Int")) {
       Buffer << 'i' << element << '_';
     } else {
-      unreachable("unexpected builtin vector type");
+      return MANGLING_ERROR(ManglingError::UnexpectedBuiltinVectorType, node);
     }
     Buffer << "Bv" << text.substr(0, splitIdx) << '_';
   } else {
-    unreachable("unexpected builtin type");
+    return MANGLING_ERROR(ManglingError::UnexpectedBuiltinType, node);
   }
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleBuiltinTupleType(Node *node, unsigned depth) {
+  Buffer << "BT";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleCFunctionPointer(Node *node) {
+ManglingError Remangler::mangleCFunctionPointer(Node *node, unsigned depth) {
   if (node->getNumChildren() > 0 &&
       node->getFirstChild()->getKind() == Node::Kind::ClangType) {
     for (size_t Idx = node->getNumChildren() - 1; Idx >= 1; --Idx) {
-      mangleChildNode(node, Idx);
+      RETURN_IF_ERROR(mangleChildNode(node, Idx, depth + 1));
     }
     Buffer << "XzC";
-    mangleClangType(node->getFirstChild());
-    return;
+    return mangleClangType(node->getFirstChild(), depth + 1);
   }
-  mangleChildNodesReversed(node); // argument tuple, result type
+  RETURN_IF_ERROR(
+      mangleChildNodesReversed(node, depth + 1)); // argument tuple, result type
   Buffer << "XC";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleClass(Node *node) {
-  mangleAnyNominalType(node);
+ManglingError Remangler::mangleClass(Node *node, unsigned depth) {
+  return mangleAnyNominalType(node, depth + 1);
 }
 
-void Remangler::mangleAnyConstructor(Node *node, char kindOp) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleAnyConstructor(Node *node, char kindOp,
+                                              unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "f" << kindOp;
+  return ManglingError::Success;
 }
 
-void Remangler::mangleConstructor(Node *node) {
-  mangleAnyConstructor(node, 'c');
+ManglingError Remangler::mangleConstructor(Node *node, unsigned depth) {
+  return mangleAnyConstructor(node, 'c', depth);
 }
 
-void Remangler::mangleCoroutineContinuationPrototype(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleCoroutineContinuationPrototype(Node *node,
+                                                              unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "TC";
+  return ManglingError::Success;
 }
 
-void Remangler::manglePredefinedObjCAsyncCompletionHandlerImpl(Node *node) {
-  mangleChildNodes(node);
+ManglingError
+Remangler::manglePredefinedObjCAsyncCompletionHandlerImpl(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "TZ";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleObjCAsyncCompletionHandlerImpl(Node *node) {
-  mangleChildNode(node, 0);
-  mangleChildNode(node, 1);
+ManglingError Remangler::mangleObjCAsyncCompletionHandlerImpl(Node *node,
+                                                              unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
   if (node->getNumChildren() == 4)
-    mangleChildNode(node, 3);
+    RETURN_IF_ERROR(mangleChildNode(node, 3, depth + 1));
   Buffer << "Tz";
-  mangleChildNode(node, 2);
+  return mangleChildNode(node, 2, depth + 1);
 }
 
-void Remangler::mangleDeallocator(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleDeallocator(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "fD";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDeclContext(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleDeclContext(Node *node, unsigned depth) {
+  return mangleSingleChildNode(node, depth + 1);
 }
 
-void Remangler::mangleDefaultArgumentInitializer(Node *node) {
-  mangleChildNode(node, 0);
+ManglingError Remangler::mangleDefaultArgumentInitializer(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
   Buffer << "fA";
-  mangleChildNode(node, 1);
+  return mangleChildNode(node, 1, depth + 1);
 }
 
-void Remangler::mangleAsyncFunctionPointer(Node *node) {
+ManglingError Remangler::mangleAsyncFunctionPointer(Node *node,
+                                                    unsigned depth) {
   Buffer << "Tu";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDependentAssociatedTypeRef(Node *node) {
-  mangleIdentifier(node->getFirstChild());
+ManglingError Remangler::mangleDependentAssociatedTypeRef(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleIdentifier(node->getFirstChild(), depth));
   if (node->getNumChildren() > 1)
-    mangleChildNode(node, 1);
+    return mangleChildNode(node, 1, depth + 1);
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDependentGenericConformanceRequirement(Node *node) {
+ManglingError
+Remangler::mangleDependentGenericConformanceRequirement(Node *node,
+                                                        unsigned depth) {
+  DEMANGLER_ASSERT(node->getNumChildren() == 2, node);
   Node *ProtoOrClass = node->getChild(1);
+  DEMANGLER_ASSERT(ProtoOrClass->hasChildren(), ProtoOrClass);
   if (ProtoOrClass->getFirstChild()->getKind() == Node::Kind::Protocol) {
-    manglePureProtocol(ProtoOrClass);
-    auto NumMembersAndParamIdx = mangleConstrainedType(node->getChild(0));
-    assert(NumMembersAndParamIdx.first < 0 || NumMembersAndParamIdx.second);
+    RETURN_IF_ERROR(manglePureProtocol(ProtoOrClass, depth + 1));
+    auto Mangling = mangleConstrainedType(node->getChild(0), depth + 1);
+    if (!Mangling.isSuccess())
+      return Mangling.error();
+    auto NumMembersAndParamIdx = Mangling.result();
+    DEMANGLER_ASSERT(
+        NumMembersAndParamIdx.first < 0 || NumMembersAndParamIdx.second, node);
     switch (NumMembersAndParamIdx.first) {
-      case -1: Buffer << "RQ"; return; // substitution
-      case 0: Buffer << "R"; break;
-      case 1: Buffer << "Rp"; break;
-      default: Buffer << "RP"; break;
+    case -1:
+      Buffer << "RQ";
+      return ManglingError::Success; // substitution
+    case 0:
+      Buffer << "R";
+      break;
+    case 1:
+      Buffer << "Rp";
+      break;
+    default:
+      Buffer << "RP";
+      break;
     }
     mangleDependentGenericParamIndex(NumMembersAndParamIdx.second);
-    return;
+    return ManglingError::Success;
   }
-  mangle(ProtoOrClass);
-  auto NumMembersAndParamIdx = mangleConstrainedType(node->getChild(0));
-  assert(NumMembersAndParamIdx.first < 0 || NumMembersAndParamIdx.second);
+  RETURN_IF_ERROR(mangle(ProtoOrClass, depth + 1));
+  auto Mangling = mangleConstrainedType(node->getChild(0), depth + 1);
+  if (!Mangling.isSuccess())
+    return Mangling.error();
+  auto NumMembersAndParamIdx = Mangling.result();
+  DEMANGLER_ASSERT(
+      NumMembersAndParamIdx.first < 0 || NumMembersAndParamIdx.second, node);
   switch (NumMembersAndParamIdx.first) {
-    case -1: Buffer << "RB"; return; // substitution
-    case 0: Buffer << "Rb"; break;
-    case 1: Buffer << "Rc"; break;
-    default: Buffer << "RC"; break;
+  case -1:
+    Buffer << "RB";
+    return ManglingError::Success; // substitution
+  case 0:
+    Buffer << "Rb";
+    break;
+  case 1:
+    Buffer << "Rc";
+    break;
+  default:
+    Buffer << "RC";
+    break;
   }
   mangleDependentGenericParamIndex(NumMembersAndParamIdx.second);
-  return;
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDependentGenericParamCount(Node *node) {
-  unreachable("handled inline in DependentGenericSignature");
+ManglingError Remangler::mangleDependentGenericInverseConformanceRequirement(
+                                                  Node *node, unsigned depth) {
+  DEMANGLER_ASSERT(node->getNumChildren() == 2, node);
+  auto Mangling = mangleConstrainedType(node->getChild(0), depth + 1);
+
+  if (!Mangling.isSuccess()) {
+    return Mangling.error();
+  }
+
+  auto NumMembersAndParamIdx = Mangling.result();
+  DEMANGLER_ASSERT(
+      NumMembersAndParamIdx.first < 0 || NumMembersAndParamIdx.second, node);
+
+  switch (NumMembersAndParamIdx.first) {
+  case -1:
+    Buffer << "RI";
+    mangleIndex(node->getChild(1)->getIndex());
+    return ManglingError::Success; // substitution
+  case 0:
+    Buffer << "Ri";
+    break;
+  case 1:
+    Buffer << "Rj";
+    break;
+  default:
+    Buffer << "RJ";
+    break;
+  }
+
+  mangleIndex(node->getChild(1)->getIndex());
+  mangleDependentGenericParamIndex(NumMembersAndParamIdx.second);
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDependentGenericParamType(Node *node) {
+ManglingError Remangler::mangleDependentGenericParamCount(Node *node,
+                                                          unsigned depth) {
+  // handled inline in DependentGenericSignature
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
+}
+
+ManglingError Remangler::mangleDependentGenericParamType(Node *node,
+                                                         unsigned depth) {
   if (node->getChild(0)->getIndex() == 0
       && node->getChild(1)->getIndex() == 0) {
     Buffer << 'x';
-    return;
+    return ManglingError::Success;
   }
   Buffer << 'q';
   mangleDependentGenericParamIndex(node);
-}
-
-void Remangler::mangleDependentGenericSameTypeRequirement(Node *node) {
-  mangleChildNode(node, 1);
-  auto NumMembersAndParamIdx = mangleConstrainedType(node->getChild(0));
-  assert(NumMembersAndParamIdx.first < 0 || NumMembersAndParamIdx.second);
+  return ManglingError::Success;
+}
+
+ManglingError
+Remangler::mangleDependentGenericSameTypeRequirement(Node *node,
+                                                     unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  auto Mangling = mangleConstrainedType(node->getChild(0), depth + 1);
+  if (!Mangling.isSuccess())
+    return Mangling.error();
+  auto NumMembersAndParamIdx = Mangling.result();
+  DEMANGLER_ASSERT(
+      NumMembersAndParamIdx.first < 0 || NumMembersAndParamIdx.second, node);
+  switch (NumMembersAndParamIdx.first) {
+  case -1:
+    Buffer << "RS";
+    return ManglingError::Success; // substitution
+  case 0:
+    Buffer << "Rs";
+    break;
+  case 1:
+    Buffer << "Rt";
+    break;
+  default:
+    Buffer << "RT";
+    break;
+  }
+  mangleDependentGenericParamIndex(NumMembersAndParamIdx.second);
+  return ManglingError::Success;
+}
+
+ManglingError
+Remangler::mangleDependentGenericSameShapeRequirement(Node *node,
+                                                      unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  auto Mangling = mangleConstrainedType(node->getChild(0), depth + 1);
+  if (!Mangling.isSuccess())
+    return Mangling.error();
+  auto NumMembersAndParamIdx = Mangling.result();
+  DEMANGLER_ASSERT(
+      NumMembersAndParamIdx.first < 0 || NumMembersAndParamIdx.second, node);
   switch (NumMembersAndParamIdx.first) {
-    case -1: Buffer << "RS"; return; // substitution
-    case 0: Buffer << "Rs"; break;
-    case 1: Buffer << "Rt"; break;
-    default: Buffer << "RT"; break;
+  case 0:
+    Buffer << "Rh";
+    break;
+  default:
+    assert(false && "Invalid same-shape requirement");
+    return ManglingError::AssertionFailed;
   }
   mangleDependentGenericParamIndex(NumMembersAndParamIdx.second);
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDependentGenericLayoutRequirement(Node *node) {
-  auto NumMembersAndParamIdx = mangleConstrainedType(node->getChild(0));
-  assert(NumMembersAndParamIdx.first < 0 || NumMembersAndParamIdx.second);
+ManglingError
+Remangler::mangleDependentGenericLayoutRequirement(Node *node, unsigned depth) {
+  auto Mangling = mangleConstrainedType(node->getChild(0), depth + 1);
+  if (!Mangling.isSuccess())
+    return Mangling.error();
+  auto NumMembersAndParamIdx = Mangling.result();
+  DEMANGLER_ASSERT(
+      NumMembersAndParamIdx.first < 0 || NumMembersAndParamIdx.second, node);
   switch (NumMembersAndParamIdx.first) {
     case -1: Buffer << "RL"; break; // substitution
     case 0: Buffer << "Rl"; break;
@@ -925,16 +1217,19 @@ void Remangler::mangleDependentGenericLayoutRequirement(Node *node) {
   // If not a substitution, mangle the dependent generic param index.
   if (NumMembersAndParamIdx.first != -1)
     mangleDependentGenericParamIndex(NumMembersAndParamIdx.second);
-  assert(node->getChild(1)->getKind() == Node::Kind::Identifier);
-  assert(node->getChild(1)->getText().size() == 1);
+  DEMANGLER_ASSERT(node->getChild(1)->getKind() == Node::Kind::Identifier,
+                   node);
+  DEMANGLER_ASSERT(node->getChild(1)->getText().size() == 1, node);
   Buffer << node->getChild(1)->getText()[0];
-  if (node->getNumChildren() >=3)
-    mangleChildNode(node, 2);
-  if (node->getNumChildren() >=4)
-    mangleChildNode(node, 3);
+  if (node->getNumChildren() >= 3)
+    RETURN_IF_ERROR(mangleChildNode(node, 2, depth + 1));
+  if (node->getNumChildren() >= 4)
+    RETURN_IF_ERROR(mangleChildNode(node, 3, depth + 1));
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDependentGenericSignature(Node *node) {
+ManglingError Remangler::mangleDependentGenericSignature(Node *node,
+                                                         unsigned depth) {
   size_t ParamCountEnd = 0;
   for (size_t Idx = 0, Num = node->getNumChildren(); Idx < Num; ++Idx) {
     Node *Child = node->getChild(Idx);
@@ -942,13 +1237,13 @@ void Remangler::mangleDependentGenericSignature(Node *node) {
       ParamCountEnd = Idx + 1;
     } else {
       // requirement
-      mangleChildNode(node, Idx);
+      RETURN_IF_ERROR(mangleChildNode(node, Idx, depth + 1));
     }
   }
   // If there's only one generic param, mangle nothing.
   if (ParamCountEnd == 1 && node->getChild(0)->getIndex() == 1) {
     Buffer << 'l';
-    return;
+    return ManglingError::Success;
   }
 
   // Remangle generic params.
@@ -962,20 +1257,36 @@ void Remangler::mangleDependentGenericSignature(Node *node) {
     }
   }
   Buffer << 'l';
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleDependentGenericParamPackMarker(Node *node,
+                                                      unsigned depth) {
+  DEMANGLER_ASSERT(node->getNumChildren() == 1, node);
+  DEMANGLER_ASSERT(node->getChild(0)->getKind() == Node::Kind::Type, node);
+  Buffer << "Rv";
+  mangleDependentGenericParamIndex(node->getChild(0)->getChild(0));
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDependentGenericType(Node *node) {
-  mangleChildNodesReversed(node); // type, generic signature
+ManglingError Remangler::mangleDependentGenericType(Node *node,
+                                                    unsigned depth) {
+  RETURN_IF_ERROR(
+      mangleChildNodesReversed(node, depth + 1)); // type, generic signature
   Buffer << 'u';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDependentMemberType(Node *node) {
-  auto NumMembersAndParamIdx = mangleConstrainedType(node);
+ManglingError Remangler::mangleDependentMemberType(Node *node, unsigned depth) {
+  auto Mangling = mangleConstrainedType(node, depth + 1);
+  if (!Mangling.isSuccess())
+    return Mangling.error();
+  auto NumMembersAndParamIdx = Mangling.result();
   switch (NumMembersAndParamIdx.first) {
     case -1:
       break; // substitution
     case 0:
-      unreachable("wrong dependent member type");
+      return MANGLING_ERROR(ManglingError::WrongDependentMemberType, node);
     case 1:
       Buffer << 'Q';
       if (auto dependentBase = NumMembersAndParamIdx.second) {
@@ -993,122 +1304,174 @@ void Remangler::mangleDependentMemberType(Node *node) {
       }
       break;
   }
+
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDependentPseudogenericSignature(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleDependentPseudogenericSignature(Node *node,
+                                                               unsigned depth) {
+  return mangleDependentGenericSignature(node, depth + 1);
 }
 
-void Remangler::mangleDestructor(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleDestructor(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "fd";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDidSet(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "W");
+ManglingError Remangler::mangleDidSet(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "W", depth + 1);
 }
 
-void Remangler::mangleDirectness(Node *node) {
-  if (node->getIndex() == unsigned(Directness::Direct)) {
+ManglingError Remangler::mangleDirectness(Node *node, unsigned depth) {
+  switch (node->getIndex()) {
+  case unsigned(Directness::Direct):
     Buffer << 'd';
-  } else {
-    assert(node->getIndex() == unsigned(Directness::Indirect));
+    break;
+  case unsigned(Directness::Indirect):
     Buffer << 'i';
+    break;
+  default:
+    return MANGLING_ERROR(ManglingError::BadDirectness, node);
   }
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDynamicAttribute(Node *node) {
+ManglingError Remangler::mangleDynamicAttribute(Node *node, unsigned depth) {
   Buffer << "TD";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDirectMethodReferenceAttribute(Node *node) {
+ManglingError Remangler::mangleDirectMethodReferenceAttribute(Node *node,
+                                                              unsigned depth) {
   Buffer << "Td";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDynamicSelf(Node *node) {
-  mangleSingleChildNode(node); // type
+ManglingError Remangler::mangleDynamicSelf(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1)); // type
   Buffer << "XD";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleEnum(Node *node) {
-  mangleAnyNominalType(node);
+ManglingError Remangler::mangleEnum(Node *node, unsigned depth) {
+  return mangleAnyNominalType(node, depth + 1);
 }
 
-void Remangler::mangleErrorType(Node *node) {
+ManglingError Remangler::mangleErrorType(Node *node, unsigned depth) {
   Buffer << "Xe";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleConstrainedExistential(Node *node,
+                                                      unsigned int depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  Buffer << "XP";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleExistentialMetatype(Node *node) {
+ManglingError
+Remangler::mangleConstrainedExistentialRequirementList(Node *node,
+                                                       unsigned int depth) {
+  assert(node->getNumChildren() > 0);
+  bool FirstElem = true;
+  for (size_t Idx = 0, Num = node->getNumChildren(); Idx < Num; ++Idx) {
+    RETURN_IF_ERROR(mangleChildNode(node, Idx, depth + 1));
+    mangleListSeparator(FirstElem);
+  }
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleConstrainedExistentialSelf(Node *node,
+                                                          unsigned int depth) {
+  Buffer << "s";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleExistentialMetatype(Node *node, unsigned depth) {
   if (node->getFirstChild()->getKind() == Node::Kind::MetatypeRepresentation) {
-    mangleChildNode(node, 1);
+    RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
     Buffer << "Xm";
-    mangleChildNode(node, 0);
+    return mangleChildNode(node, 0, depth + 1);
   } else {
-    mangleSingleChildNode(node);
+    RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
     Buffer << "Xp";
   }
+  return ManglingError::Success;
 }
 
-void Remangler::mangleExplicitClosure(Node *node) {
-  mangleChildNode(node, 0); // context
-  mangleChildNode(node, 2); // type
+ManglingError Remangler::mangleExplicitClosure(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1)); // context
+  RETURN_IF_ERROR(mangleChildNode(node, 2, depth + 1)); // type
   Buffer << "fU";
-  mangleChildNode(node, 1); // index
+  return mangleChildNode(node, 1, depth + 1); // index
 }
 
-void Remangler::mangleExtension(Node *node) {
-  mangleChildNode(node, 1);
-  mangleChildNode(node, 0);
+ManglingError Remangler::mangleExtension(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
   if (node->getNumChildren() == 3)
-    mangleChildNode(node, 2); // generic signature
+    RETURN_IF_ERROR(mangleChildNode(node, 2, depth + 1)); // generic signature
   Buffer << 'E';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAnonymousContext(Node *node) {
-  mangleChildNode(node, 1);
-  mangleChildNode(node, 0);
+ManglingError Remangler::mangleAnonymousContext(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
   if (node->getNumChildren() >= 3)
-    mangleTypeList(node->getChild(2));
+    RETURN_IF_ERROR(mangleTypeList(node->getChild(2), depth + 1));
+  else
+    Buffer << 'y';
   Buffer << "XZ";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleFieldOffset(Node *node) {
-  mangleChildNode(node, 1); // variable
+ManglingError Remangler::mangleFieldOffset(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1)); // variable
   Buffer << "Wv";
-  mangleChildNode(node, 0); // directness
+  return mangleChildNode(node, 0, depth + 1); // directness
 }
 
-void Remangler::mangleEnumCase(Node *node) {
-  mangleSingleChildNode(node); // enum case
+ManglingError Remangler::mangleEnumCase(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1)); // enum case
   Buffer << "WC";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleFullTypeMetadata(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleFullTypeMetadata(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mf";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleFunction(Node *node) {
-  mangleChildNode(node, 0); // context
-  mangleChildNode(node, 1); // name
+ManglingError Remangler::mangleFunction(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1)); // context
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1)); // name
 
   bool hasLabels = node->getChild(2)->getKind() == Node::Kind::LabelList;
   Node *FuncType = getSingleChild(node->getChild(hasLabels ? 3 : 2));
 
   if (hasLabels)
-    mangleChildNode(node, 2); // parameter labels
+    RETURN_IF_ERROR(mangleChildNode(node, 2, depth + 1)); // parameter labels
 
   if (FuncType->getKind() == Node::Kind::DependentGenericType) {
-    mangleFunctionSignature(getSingleChild(FuncType->getChild(1)));
-    mangleChildNode(FuncType, 0); // generic signature
+    RETURN_IF_ERROR(mangleFunctionSignature(
+        getSingleChild(FuncType->getChild(1)), depth + 1));
+    RETURN_IF_ERROR(
+        mangleChildNode(FuncType, 0, depth + 1)); // generic signature
   } else {
-    mangleFunctionSignature(FuncType);
+    RETURN_IF_ERROR(mangleFunctionSignature(FuncType, depth + 1));
   }
 
   Buffer << "F";
+
+  return ManglingError::Success;
 }
 
-void Remangler::mangleFunctionSignatureSpecialization(Node *node) {
+ManglingError Remangler::mangleFunctionSignatureSpecialization(Node *node,
+                                                               unsigned depth) {
   for (NodePointer Param : *node) {
     if (Param->getKind() == Node::Kind::FunctionSignatureSpecializationParam &&
         Param->getNumChildren() > 0) {
@@ -1116,7 +1479,7 @@ void Remangler::mangleFunctionSignatureSpecialization(Node *node) {
       switch (FunctionSigSpecializationParamKind(KindNd->getIndex())) {
         case FunctionSigSpecializationParamKind::ConstantPropFunction:
         case FunctionSigSpecializationParamKind::ConstantPropGlobal:
-          mangleIdentifier(Param->getChild(1));
+          RETURN_IF_ERROR(mangleIdentifier(Param->getChild(1), depth + 1));
           break;
         case FunctionSigSpecializationParamKind::ConstantPropString: {
           NodePointer TextNd = Param->getChild(2);
@@ -1126,13 +1489,14 @@ void Remangler::mangleFunctionSignatureSpecialization(Node *node) {
             Buffer.append(Text.data(), Text.size());
             TextNd = Factory.createNode(Node::Kind::Identifier, Buffer);
           }
-          mangleIdentifier(TextNd);
+          RETURN_IF_ERROR(mangleIdentifier(TextNd, depth + 1));
           break;
         }
         case FunctionSigSpecializationParamKind::ClosureProp:
-          mangleIdentifier(Param->getChild(1));
+        case FunctionSigSpecializationParamKind::ConstantPropKeyPath:
+          RETURN_IF_ERROR(mangleIdentifier(Param->getChild(1), depth + 1));
           for (unsigned i = 2, e = Param->getNumChildren(); i != e; ++i) {
-            mangleType(Param->getChild(i));
+            RETURN_IF_ERROR(mangleType(Param->getChild(i), depth + 1));
           }
           break;
         default:
@@ -1147,7 +1511,7 @@ void Remangler::mangleFunctionSignatureSpecialization(Node *node) {
       Buffer << '_';
       returnValMangled = true;
     }
-    mangle(Child);
+    RETURN_IF_ERROR(mangle(Child, depth + 1));
 
     if (Child->getKind() == Node::Kind::SpecializationPassID &&
         node->hasIndex()) {
@@ -1156,16 +1520,22 @@ void Remangler::mangleFunctionSignatureSpecialization(Node *node) {
   }
   if (!returnValMangled)
     Buffer << "_n";
+
+  return ManglingError::Success;
 }
 
-void Remangler::mangleFunctionSignatureSpecializationReturn(Node *node) {
-  mangleFunctionSignatureSpecializationParam(node);
+ManglingError
+Remangler::mangleFunctionSignatureSpecializationReturn(Node *node,
+                                                       unsigned depth) {
+  return mangleFunctionSignatureSpecializationParam(node, depth + 1);
 }
 
-void Remangler::mangleFunctionSignatureSpecializationParam(Node *node) {
+ManglingError
+Remangler::mangleFunctionSignatureSpecializationParam(Node *node,
+                                                      unsigned depth) {
   if (!node->hasChildren()) {
     Buffer << 'n';
-    return;
+    return ManglingError::Success;
   }
 
   // The first child is always a kind that specifies the type of param that we
@@ -1177,16 +1547,16 @@ void Remangler::mangleFunctionSignatureSpecializationParam(Node *node) {
   switch (kind) {
     case FunctionSigSpecializationParamKind::ConstantPropFunction:
       Buffer << "pf";
-      return;
+      break;
     case FunctionSigSpecializationParamKind::ConstantPropGlobal:
       Buffer << "pg";
-      return;
+      break;
     case FunctionSigSpecializationParamKind::ConstantPropInteger:
       Buffer << "pi" << node->getChild(1)->getText();
-      return;
+      break;
     case FunctionSigSpecializationParamKind::ConstantPropFloat:
       Buffer << "pd" << node->getChild(1)->getText();
-      return;
+      break;
     case FunctionSigSpecializationParamKind::ConstantPropString: {
       Buffer << "ps";
       StringRef encodingStr = node->getChild(1)->getText();
@@ -1197,22 +1567,28 @@ void Remangler::mangleFunctionSignatureSpecializationParam(Node *node) {
       } else if (encodingStr == "objc") {
         Buffer << 'c';
       } else {
-        unreachable("Unknown encoding");
+        return MANGLING_ERROR(ManglingError::UnknownEncoding, node);
       }
-      return;
+      break;
     }
+    case FunctionSigSpecializationParamKind::ConstantPropKeyPath:
+      Buffer << "pk";
+      break;
     case FunctionSigSpecializationParamKind::ClosureProp:
       Buffer << 'c';
-      return;
+      break;
     case FunctionSigSpecializationParamKind::BoxToValue:
       Buffer << 'i';
-      return;
+      break;
     case FunctionSigSpecializationParamKind::BoxToStack:
       Buffer << 's';
-      return;
+      break;
+    case FunctionSigSpecializationParamKind::InOutToOut:
+      Buffer << 'r';
+      break;
     case FunctionSigSpecializationParamKind::SROA:
       Buffer << 'x';
-      return;
+      break;
     default:
       if (kindValue &
           unsigned(
@@ -1245,42 +1621,58 @@ void Remangler::mangleFunctionSignatureSpecializationParam(Node *node) {
       }
       if (kindValue & unsigned(FunctionSigSpecializationParamKind::SROA))
         Buffer << 'X';
-      return;
+      break;
   }
+
+  return ManglingError::Success;
 }
 
-void Remangler::mangleFunctionSignatureSpecializationParamKind(Node *node) {
-  unreachable("handled inline");
+ManglingError
+Remangler::mangleFunctionSignatureSpecializationParamKind(Node *node,
+                                                          unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleFunctionSignatureSpecializationParamPayload(Node *node) {
-  unreachable("handled inline");
+ManglingError
+Remangler::mangleFunctionSignatureSpecializationParamPayload(Node *node,
+                                                             unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleFunctionType(Node *node) {
-  mangleFunctionSignature(node);
+ManglingError Remangler::mangleFunctionType(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleFunctionSignature(node, depth + 1));
   Buffer << 'c';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGenericProtocolWitnessTable(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleGenericProtocolWitnessTable(Node *node,
+                                                           unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "WG";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGenericProtocolWitnessTableInstantiationFunction(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleGenericProtocolWitnessTableInstantiationFunction(
+    Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "WI";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleResilientProtocolWitnessTable(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleResilientProtocolWitnessTable(Node *node,
+                                                             unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Wr";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGenericPartialSpecialization(Node *node) {
+ManglingError Remangler::mangleGenericPartialSpecialization(Node *node,
+                                                            unsigned depth) {
   for (NodePointer Child : *node) {
     if (Child->getKind() == Node::Kind::GenericSpecializationParam) {
-      mangleChildNode(Child, 0);
+      RETURN_IF_ERROR(mangleChildNode(Child, 0, depth + 1));
       break;
     }
   }
@@ -1288,73 +1680,94 @@ void Remangler::mangleGenericPartialSpecialization(Node *node) {
         Node::Kind::GenericPartialSpecializationNotReAbstracted ? "TP" : "Tp");
   for (NodePointer Child : *node) {
     if (Child->getKind() != Node::Kind::GenericSpecializationParam)
-      mangle(Child);
+      RETURN_IF_ERROR(mangle(Child, depth + 1));
   }
+
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGenericPartialSpecializationNotReAbstracted(Node *node) {
-  mangleGenericPartialSpecialization(node);
+ManglingError
+Remangler::mangleGenericPartialSpecializationNotReAbstracted(Node *node,
+                                                             unsigned depth) {
+  return mangleGenericPartialSpecialization(node, depth + 1);
 }
 
-void Remangler::
-mangleGenericSpecializationNode(Node *node, const char *operatorStr) {
+ManglingError
+Remangler::mangleGenericSpecializationNode(Node *node, const char *operatorStr,
+                                           unsigned depth) {
   bool FirstParam = true;
   for (NodePointer Child : *node) {
     if (Child->getKind() == Node::Kind::GenericSpecializationParam) {
-      mangleChildNode(Child, 0);
+      RETURN_IF_ERROR(mangleChildNode(Child, 0, depth + 1));
       mangleListSeparator(FirstParam);
     }
   }
-  assert(!FirstParam && "generic specialization with no substitutions");
+  DEMANGLER_ASSERT(
+      !FirstParam && "generic specialization with no substitutions", node);
 
   Buffer << operatorStr;
 
   for (NodePointer Child : *node) {
     if (Child->getKind() != Node::Kind::GenericSpecializationParam)
-      mangle(Child);
+      RETURN_IF_ERROR(mangle(Child, depth + 1));
   }
-}
 
-void Remangler::mangleGenericSpecialization(Node *node) {
-  mangleGenericSpecializationNode(node, "Tg");
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGenericSpecializationPrespecialized(Node *node) {
-  mangleGenericSpecializationNode(node, "Ts");
+ManglingError Remangler::mangleGenericSpecialization(Node *node,
+                                                     unsigned depth) {
+  return mangleGenericSpecializationNode(node, "Tg", depth + 1);
 }
 
-void Remangler::mangleGenericSpecializationNotReAbstracted(Node *node) {
-  mangleGenericSpecializationNode(node, "TG");
+ManglingError
+Remangler::mangleGenericSpecializationPrespecialized(Node *node,
+                                                     unsigned depth) {
+  return mangleGenericSpecializationNode(node, "Ts", depth + 1);
 }
 
-void Remangler::mangleGenericSpecializationInResilienceDomain(Node *node) {
-  mangleGenericSpecializationNode(node, "TB");
+ManglingError
+Remangler::mangleGenericSpecializationNotReAbstracted(Node *node,
+                                                      unsigned depth) {
+  return mangleGenericSpecializationNode(node, "TG", depth + 1);
 }
 
-void Remangler::mangleInlinedGenericFunction(Node *node) {
-  mangleGenericSpecializationNode(node, "Ti");
+ManglingError
+Remangler::mangleGenericSpecializationInResilienceDomain(Node *node,
+                                                         unsigned depth) {
+  return mangleGenericSpecializationNode(node, "TB", depth + 1);
 }
 
+ManglingError Remangler::mangleInlinedGenericFunction(Node *node,
+                                                      unsigned depth) {
+  return mangleGenericSpecializationNode(node, "Ti", depth + 1);
+}
 
-void Remangler::mangleGenericSpecializationParam(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleGenericSpecializationParam(Node *node,
+                                                          unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleGenericTypeMetadataPattern(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleGenericTypeMetadataPattern(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "MP";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGenericTypeParamDecl(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleGenericTypeParamDecl(Node *node,
+                                                    unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "fp";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGetter(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "g");
+ManglingError Remangler::mangleGetter(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "g", depth + 1);
 }
 
-void Remangler::mangleGlobal(Node *node) {
+ManglingError Remangler::mangleGlobal(Node *node, unsigned depth) {
   Buffer << MANGLING_PREFIX_STR;
   bool mangleInReverseOrder = false;
   for (auto Iter = node->begin(), End = node->end(); Iter != End; ++Iter) {
@@ -1370,96 +1783,144 @@ void Remangler::mangleGlobal(Node *node) {
       case Node::Kind::GenericPartialSpecializationNotReAbstracted:
       case Node::Kind::OutlinedBridgedMethod:
       case Node::Kind::OutlinedVariable:
+      case Node::Kind::OutlinedReadOnlyObject:
       case Node::Kind::ObjCAttribute:
       case Node::Kind::NonObjCAttribute:
       case Node::Kind::DynamicAttribute:
       case Node::Kind::VTableAttribute:
       case Node::Kind::DirectMethodReferenceAttribute:
       case Node::Kind::MergedFunction:
+      case Node::Kind::DistributedThunk:
+      case Node::Kind::DistributedAccessor:
       case Node::Kind::DynamicallyReplaceableFunctionKey:
       case Node::Kind::DynamicallyReplaceableFunctionImpl:
       case Node::Kind::DynamicallyReplaceableFunctionVar:
       case Node::Kind::AsyncFunctionPointer:
       case Node::Kind::AsyncAwaitResumePartialFunction:
       case Node::Kind::AsyncSuspendResumePartialFunction:
+      case Node::Kind::AccessibleFunctionRecord:
+      case Node::Kind::BackDeploymentThunk:
+      case Node::Kind::BackDeploymentFallback:
+      case Node::Kind::HasSymbolQuery:
         mangleInReverseOrder = true;
         break;
       default:
-        mangle(Child);
+        RETURN_IF_ERROR(mangle(Child, depth + 1));
         if (mangleInReverseOrder) {
           auto ReverseIter = Iter;
           while (ReverseIter != node->begin()) {
             --ReverseIter;
-            mangle(*ReverseIter);
+            RETURN_IF_ERROR(mangle(*ReverseIter, depth + 1));
           }
           mangleInReverseOrder = false;
         }
         break;
     }
   }
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGlobalGetter(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "G");
+ManglingError Remangler::mangleGlobalGetter(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "G", depth + 1);
 }
 
-void Remangler::mangleIdentifier(Node *node) {
+ManglingError Remangler::mangleIdentifier(Node *node, unsigned depth) {
   mangleIdentifierImpl(node, /*isOperator*/ false);
+  return ManglingError::Success;
 }
 
-void Remangler::mangleIndex(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleIndex(Node *node, unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleUnknownIndex(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleUnknownIndex(Node *node, unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleIVarInitializer(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleIVarInitializer(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "fe";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleIVarDestroyer(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleIVarDestroyer(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "fE";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleImplDifferentiabilityKind(Node *node) {
+ManglingError Remangler::mangleImplDifferentiabilityKind(Node *node,
+                                                         unsigned depth) {
   Buffer << (char)node->getIndex();
+  return ManglingError::Success;
 }
 
-void Remangler::mangleImplEscaping(Node *node) {
+ManglingError Remangler::mangleImplEscaping(Node *node, unsigned depth) {
   Buffer << 'e';
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleImplErasedIsolation(Node *node, unsigned depth) {
+  Buffer << 'A';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleImplConvention(Node *node) {
+ManglingError Remangler::mangleImplSendingResult(Node *node, unsigned depth) {
+  Buffer << 'T';
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleImplConvention(Node *node, unsigned depth) {
   char ConvCh = llvm::StringSwitch<char>(node->getText())
                   .Case("@callee_unowned", 'y')
                   .Case("@callee_guaranteed", 'g')
                   .Case("@callee_owned", 'x')
                   .Default(0);
-  assert(ConvCh && "invalid impl callee convention");
+  if (!ConvCh)
+    return MANGLING_ERROR(ManglingError::InvalidImplCalleeConvention, node);
   Buffer << ConvCh;
+  return ManglingError::Success;
 }
 
-void Remangler::mangleImplParameterResultDifferentiability(Node *node) {
-  assert(node->hasText());
+ManglingError
+Remangler::mangleImplParameterResultDifferentiability(Node *node,
+                                                      unsigned depth) {
+  DEMANGLER_ASSERT(node->hasText(), node);
   // Empty string represents default differentiability.
   if (node->getText().empty())
-    return;
+    return ManglingError::Success;
   char diffChar = llvm::StringSwitch<char>(node->getText())
                       .Case("@noDerivative", 'w')
                       .Default(0);
-  assert(diffChar && "Invalid impl differentiability");
+  if (!diffChar)
+    return MANGLING_ERROR(ManglingError::InvalidImplDifferentiability, node);
+  Buffer << diffChar;
+
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleImplParameterSending(Node *node,
+                                                    unsigned depth) {
+  DEMANGLER_ASSERT(node->hasText(), node);
+  char diffChar =
+      llvm::StringSwitch<char>(node->getText()).Case("sending", 'T').Default(0);
+  if (!diffChar)
+    return MANGLING_ERROR(ManglingError::InvalidImplParameterSending, node);
   Buffer << diffChar;
+
+  return ManglingError::Success;
 }
 
-void Remangler::mangleImplFunctionAttribute(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleImplFunctionAttribute(Node *node,
+                                                     unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleImplFunctionConvention(Node *node) {
+ManglingError Remangler::mangleImplFunctionConvention(Node *node,
+                                                      unsigned depth) {
   StringRef text =
       (node->getNumChildren() > 0 && node->getFirstChild()->hasText())
           ? node->getFirstChild()->getText()
@@ -1472,33 +1933,40 @@ void Remangler::mangleImplFunctionConvention(Node *node) {
                       .Case("closure", 'K')
                       .Case("witness_method", 'W')
                       .Default(0);
-  assert(FuncAttr && "invalid impl function convention");
+  DEMANGLER_ASSERT(FuncAttr && "invalid impl function convention", node);
   if ((FuncAttr == 'B' || FuncAttr == 'C') && node->getNumChildren() > 1 &&
       node->getChild(1)->getKind() == Node::Kind::ClangType) {
     Buffer << 'z' << FuncAttr;
-    mangleClangType(node->getChild(1));
-    return;
+    return mangleClangType(node->getChild(1), depth + 1);
   }
   Buffer << FuncAttr;
+  return ManglingError::Success;
 }
 
-void Remangler::mangleImplFunctionConventionName(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleImplFunctionConventionName(Node *node,
+                                                          unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleClangType(Node *node) {
+ManglingError Remangler::mangleClangType(Node *node, unsigned depth) {
   Buffer << node->getText().size() << node->getText();
+  return ManglingError::Success;
 }
 
-void Remangler::mangleImplInvocationSubstitutions(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleImplInvocationSubstitutions(Node *node,
+                                                           unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleImplPatternSubstitutions(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleImplPatternSubstitutions(Node *node,
+                                                        unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleImplFunctionType(Node *node) {
+ManglingError Remangler::mangleImplFunctionType(Node *node, unsigned depth) {
   const char *PseudoGeneric = "";
   Node *GenSig = nullptr;
   Node *PatternSubs = nullptr;
@@ -1510,8 +1978,11 @@ void Remangler::mangleImplFunctionType(Node *node) {
     case Node::Kind::ImplYield:
     case Node::Kind::ImplErrorResult:
       // Mangle type. Type should be the last child.
-      assert(Child->getNumChildren() == 2 || Child->getNumChildren() == 3);
-      mangle(Child->getLastChild());
+      DEMANGLER_ASSERT(Child->getNumChildren() == 2 ||
+                           Child->getNumChildren() == 3 ||
+                           Child->getNumChildren() == 4,
+                       node);
+      RETURN_IF_ERROR(mangle(Child->getLastChild(), depth + 1));
       break;
     case Node::Kind::DependentPseudogenericSignature:
       PseudoGeneric = "P";
@@ -1530,23 +2001,26 @@ void Remangler::mangleImplFunctionType(Node *node) {
     }
   }
   if (GenSig)
-    mangle(GenSig);
+    RETURN_IF_ERROR(mangle(GenSig, depth + 1));
   if (InvocationSubs) {
     Buffer << 'y';
-    mangleChildNodes(InvocationSubs->getChild(0));
-    if (InvocationSubs->getNumChildren() >= 2)
-      mangleRetroactiveConformance(InvocationSubs->getChild(1));
+    RETURN_IF_ERROR(mangleChildNodes(InvocationSubs->getChild(0), depth + 1));
+    if (InvocationSubs->getNumChildren() >= 2) {
+      RETURN_IF_ERROR(
+          mangleRetroactiveConformance(InvocationSubs->getChild(1), depth + 1));
+    }
   }
   if (PatternSubs) {
-    mangle(PatternSubs->getChild(0));
+    RETURN_IF_ERROR(mangle(PatternSubs->getChild(0), depth + 1));
     Buffer << 'y';
-    mangleChildNodes(PatternSubs->getChild(1));
+    RETURN_IF_ERROR(mangleChildNodes(PatternSubs->getChild(1), depth + 1));
     if (PatternSubs->getNumChildren() >= 3) {
       NodePointer retroactiveConf = PatternSubs->getChild(2);
       if (retroactiveConf->getKind() == Node::Kind::TypeList) {
-        mangleChildNodes(retroactiveConf);
+        RETURN_IF_ERROR(mangleChildNodes(retroactiveConf, depth + 1));
       } else {
-        mangleRetroactiveConformance(retroactiveConf);
+        RETURN_IF_ERROR(
+            mangleRetroactiveConformance(retroactiveConf, depth + 1));
       }
     }
   }
@@ -1567,6 +2041,12 @@ void Remangler::mangleImplFunctionType(Node *node) {
       case Node::Kind::ImplEscaping:
         Buffer << 'e';
         break;
+      case Node::Kind::ImplErasedIsolation:
+        Buffer << 'A';
+        break;
+      case Node::Kind::ImplSendingResult:
+        Buffer << 'T';
+        break;
       case Node::Kind::ImplConvention: {
         char ConvCh = llvm::StringSwitch<char>(Child->getText())
                         .Case("@callee_unowned", 'y')
@@ -1574,12 +2054,14 @@ void Remangler::mangleImplFunctionType(Node *node) {
                         .Case("@callee_owned", 'x')
                         .Case("@convention(thin)", 't')
                         .Default(0);
-        assert(ConvCh && "invalid impl callee convention");
+        if (!ConvCh)
+          return MANGLING_ERROR(ManglingError::InvalidImplCalleeConvention,
+                               Child);
         Buffer << ConvCh;
         break;
       }
       case Node::Kind::ImplFunctionConvention: {
-        mangleImplFunctionConvention(Child);
+        RETURN_IF_ERROR(mangleImplFunctionConvention(Child, depth + 1));
         break;
       }
       case Node::Kind::ImplFunctionAttribute: {
@@ -1589,7 +2071,10 @@ void Remangler::mangleImplFunctionType(Node *node) {
                         .Case("@Sendable", 'h')
                         .Case("@async", 'H')
                         .Default(0);
-        assert(FuncAttr && "invalid impl function attribute");
+        if (!FuncAttr) {
+          return MANGLING_ERROR(ManglingError::InvalidImplFunctionAttribute,
+                               Child);
+        }
         Buffer << FuncAttr;
         break;
       }
@@ -1609,12 +2094,25 @@ void Remangler::mangleImplFunctionType(Node *node) {
                 .Case("@guaranteed", 'g')
                 .Case("@deallocating", 'e')
                 .Case("@unowned", 'y')
+                .Case("@pack_guaranteed", 'p')
+                .Case("@pack_owned", 'v')
+                .Case("@pack_inout", 'm')
                 .Default(0);
-        assert(ConvCh && "invalid impl parameter convention");
+        if (!ConvCh) {
+          return MANGLING_ERROR(ManglingError::InvalidImplParameterConvention,
+                               Child->getFirstChild());
+        }
         Buffer << ConvCh;
         // Mangle parameter differentiability, if it exists.
-        if (Child->getNumChildren() == 3)
-          mangleImplParameterResultDifferentiability(Child->getChild(1));
+        if (Child->getNumChildren() == 3) {
+          RETURN_IF_ERROR(mangleImplParameterResultDifferentiability(
+              Child->getChild(1), depth + 1));
+        } else if (Child->getNumChildren() == 4) {
+          RETURN_IF_ERROR(mangleImplParameterResultDifferentiability(
+              Child->getChild(1), depth + 1));
+          RETURN_IF_ERROR(
+              mangleImplParameterSending(Child->getChild(2), depth + 1));
+        }
         break;
       }
       case Node::Kind::ImplErrorResult:
@@ -1627,12 +2125,23 @@ void Remangler::mangleImplFunctionType(Node *node) {
                         .Case("@unowned", 'd')
                         .Case("@unowned_inner_pointer", 'u')
                         .Case("@autoreleased", 'a')
+                        .Case("@pack_out", 'k')
                         .Default(0);
-        assert(ConvCh && "invalid impl parameter convention");
+        if (!ConvCh) {
+          return MANGLING_ERROR(ManglingError::InvalidImplParameterConvention,
+                               Child->getFirstChild());
+        }
         Buffer << ConvCh;
         // Mangle result differentiability, if it exists.
-        if (Child->getNumChildren() == 3)
-          mangleImplParameterResultDifferentiability(Child->getChild(1));
+        if (Child->getNumChildren() == 3) {
+          RETURN_IF_ERROR(mangleImplParameterResultDifferentiability(
+              Child->getChild(1), depth + 1));
+        } else if (Child->getNumChildren() == 4) {
+          RETURN_IF_ERROR(mangleImplParameterResultDifferentiability(
+              Child->getChild(1), depth + 1));
+          RETURN_IF_ERROR(
+              mangleImplParameterSending(Child->getChild(2), depth + 1));
+        }
         break;
       }
       default:
@@ -1640,751 +2149,1113 @@ void Remangler::mangleImplFunctionType(Node *node) {
     }
   }
   Buffer << '_';
+
+  return ManglingError::Success;
 }
 
-void Remangler::mangleImplicitClosure(Node *node) {
-  mangleChildNode(node, 0); // context
-  mangleChildNode(node, 2); // type
+ManglingError Remangler::mangleImplicitClosure(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1)); // context
+  RETURN_IF_ERROR(mangleChildNode(node, 2, depth + 1)); // type
   Buffer << "fu";
-  mangleChildNode(node, 1); // index
+  return mangleChildNode(node, 1, depth + 1); // index
 }
 
-void Remangler::mangleImplParameter(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleImplParameter(Node *node, unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleImplResult(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleImplResult(Node *node, unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleImplYield(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleImplYield(Node *node, unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleImplErrorResult(Node *node) {
-  unreachable("handled inline");
+ManglingError Remangler::mangleImplErrorResult(Node *node, unsigned depth) {
+  // handled inline
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleInOut(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleInOut(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << 'z';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleIsolated(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleIsolated(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Yi";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleSending(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
+  Buffer << "Yu";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleShared(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleCompileTimeConst(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
+  Buffer << "Yt";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleShared(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << 'h';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOwned(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleOwned(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << 'n';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleNoDerivative(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleNoDerivative(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Yk";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleInfixOperator(Node *node) {
+ManglingError Remangler::mangleParamLifetimeDependence(Node *node,
+                                                       unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  Buffer << "Yl" << (char)node->getFirstChild()->getIndex();
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleSelfLifetimeDependence(Node *node,
+                                                      unsigned depth) {
+  Buffer << "YL" << (char)node->getIndex();
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleInfixOperator(Node *node, unsigned depth) {
   mangleIdentifierImpl(node, /*isOperator*/ true);
   Buffer << "oi";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleInitializer(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleInitializer(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "fi";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleInitAccessor(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "i", depth + 1);
 }
 
-void Remangler::manglePropertyWrapperBackingInitializer(Node *node) {
-  mangleChildNodes(node);
+ManglingError
+Remangler::manglePropertyWrapperBackingInitializer(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "fP";
+  return ManglingError::Success;
 }
 
-void Remangler::manglePropertyWrapperInitFromProjectedValue(Node *node) {
-  mangleChildNodes(node);
+ManglingError
+Remangler::manglePropertyWrapperInitFromProjectedValue(Node *node,
+                                                       unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "fW";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleLazyProtocolWitnessTableAccessor(Node *node) {
-  mangleChildNodes(node);
+ManglingError
+Remangler::mangleLazyProtocolWitnessTableAccessor(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "Wl";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleLazyProtocolWitnessTableCacheVariable(Node *node) {
-  mangleChildNodes(node);
+ManglingError
+Remangler::mangleLazyProtocolWitnessTableCacheVariable(Node *node,
+                                                       unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "WL";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleLocalDeclName(Node *node) {
-  mangleChildNode(node, 1); // identifier
+ManglingError Remangler::mangleLocalDeclName(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1)); // identifier
   Buffer << 'L';
-  mangleChildNode(node, 0); // index
+  return mangleChildNode(node, 0, depth + 1); // index
 }
 
-void Remangler::mangleMaterializeForSet(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "m");
+ManglingError Remangler::mangleMaterializeForSet(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "m", depth + 1);
 }
 
-void Remangler::mangleMetatype(Node *node) {
+ManglingError Remangler::mangleMetatype(Node *node, unsigned depth) {
   if (node->getFirstChild()->getKind() == Node::Kind::MetatypeRepresentation) {
-    mangleChildNode(node, 1);
+    RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
     Buffer << "XM";
-    mangleChildNode(node, 0);
+    RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
   } else {
-    mangleSingleChildNode(node);
+    RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
     Buffer << 'm';
   }
+  return ManglingError::Success;
 }
 
-void Remangler::mangleMetatypeRepresentation(Node *node) {
-  if (node->getText() == "@thin") {
+ManglingError Remangler::mangleMetatypeRepresentation(Node *node,
+                                                      unsigned depth) {
+  auto text = node->getText();
+  if (text == "@thin") {
     Buffer << 't';
-  } else if (node->getText() == "@thick") {
+  } else if (text == "@thick") {
     Buffer << 'T';
-  } else if (node->getText() == "@objc_metatype") {
+  } else if (text == "@objc_metatype") {
     Buffer << 'o';
   } else {
-    unreachable("wrong metatype representation");
+    return MANGLING_ERROR(ManglingError::InvalidMetatypeRepresentation, node);
   }
+  return ManglingError::Success;
 }
 
-void Remangler::mangleMetaclass(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleMetaclass(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "Mm";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleModifyAccessor(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "M");
+ManglingError Remangler::mangleModifyAccessor(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "M", depth + 1);
 }
 
-void Remangler::mangleModule(Node *node) {
-  if (node->getText() == STDLIB_NAME) {
+ManglingError Remangler::mangleModule(Node *node, unsigned depth) {
+  auto text = node->getText();
+  if (text == STDLIB_NAME) {
     Buffer << 's';
-  } else if (node->getText() == MANGLING_MODULE_OBJC) {
+  } else if (text == MANGLING_MODULE_OBJC) {
     Buffer << "So";
-  } else if (node->getText() == MANGLING_MODULE_CLANG_IMPORTER) {
+  } else if (text == MANGLING_MODULE_CLANG_IMPORTER) {
     Buffer << "SC";
   } else {
-    mangleIdentifier(node);
+    return mangleIdentifier(node, depth);
   }
+  return ManglingError::Success;
 }
 
-void Remangler::mangleNativeOwningAddressor(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "lo");
+ManglingError Remangler::mangleNativeOwningAddressor(Node *node,
+                                                     unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "lo", depth + 1);
 }
 
-void Remangler::mangleNativeOwningMutableAddressor(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "ao");
+ManglingError Remangler::mangleNativeOwningMutableAddressor(Node *node,
+                                                            unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "ao", depth + 1);
 }
 
-void Remangler::mangleNativePinningAddressor(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "lp");
+ManglingError Remangler::mangleNativePinningAddressor(Node *node,
+                                                      unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "lp", depth + 1);
 }
 
-void Remangler::mangleNativePinningMutableAddressor(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "aP");
+ManglingError Remangler::mangleNativePinningMutableAddressor(Node *node,
+                                                             unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "aP", depth + 1);
 }
 
-void Remangler::mangleClassMetadataBaseOffset(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleClassMetadataBaseOffset(Node *node,
+                                                       unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mo";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleNominalTypeDescriptor(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleNominalTypeDescriptor(Node *node,
+                                                     unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mn";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleNominalTypeDescriptorRecord(Node *node,
+                                                           unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
+  Buffer << "Hn";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOpaqueTypeDescriptor(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleOpaqueTypeDescriptor(Node *node,
+                                                    unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "MQ";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleOpaqueTypeDescriptorRecord(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
+  Buffer << "Ho";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOpaqueTypeDescriptorAccessor(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleOpaqueTypeDescriptorAccessor(Node *node,
+                                                            unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mg";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOpaqueTypeDescriptorAccessorImpl(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError
+Remangler::mangleOpaqueTypeDescriptorAccessorImpl(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mh";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOpaqueTypeDescriptorAccessorKey(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleOpaqueTypeDescriptorAccessorKey(Node *node,
+                                                               unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mj";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOpaqueTypeDescriptorAccessorVar(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleOpaqueTypeDescriptorAccessorVar(Node *node,
+                                                               unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mk";
+  return ManglingError::Success;
 }
 
-void Remangler::manglePropertyDescriptor(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::manglePropertyDescriptor(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "MV";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleNonObjCAttribute(Node *node) {
+ManglingError Remangler::mangleNonObjCAttribute(Node *node, unsigned depth) {
   Buffer << "TO";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleTuple(Node *node) {
-  mangleTypeList(node);
+ManglingError Remangler::mangleTuple(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleTypeList(node, depth + 1));
   Buffer << 't';
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::manglePack(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleTypeList(node, depth + 1));
+  Buffer << "QP";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleSILPackDirect(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleTypeList(node, depth + 1));
+  Buffer << "QSd";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleSILPackIndirect(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleTypeList(node, depth + 1));
+  Buffer << "QSi";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::manglePackExpansion(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
+  Buffer << "Qp";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::manglePackElement(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
+  Buffer << "Qe";
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::manglePackElementLevel(Node *node, unsigned depth) {
+  mangleIndex(node->getIndex());
+  return ManglingError::Success;
 }
 
-void Remangler::mangleNumber(Node *node) {
+ManglingError Remangler::mangleNumber(Node *node, unsigned depth) {
   mangleIndex(node->getIndex());
+  return ManglingError::Success;
 }
 
-void Remangler::mangleObjCAttribute(Node *node) {
+ManglingError Remangler::mangleObjCAttribute(Node *node, unsigned depth) {
   Buffer << "To";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleObjCBlock(Node *node) {
+ManglingError Remangler::mangleObjCBlock(Node *node, unsigned depth) {
   if (node->getNumChildren() > 0 &&
       node->getFirstChild()->getKind() == Node::Kind::ClangType) {
     for (size_t Idx = node->getNumChildren() - 1; Idx >= 1; --Idx) {
-      mangleChildNode(node, Idx);
+      RETURN_IF_ERROR(mangleChildNode(node, Idx, depth + 1));
     }
     Buffer << "XzB";
-    mangleClangType(node->getFirstChild());
-    return;
+    return mangleClangType(node->getFirstChild(), depth + 1);
   }
-  mangleChildNodesReversed(node);
+  RETURN_IF_ERROR(mangleChildNodesReversed(node, depth + 1));
   Buffer << "XB";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleEscapingObjCBlock(Node *node) {
-  mangleChildNodesReversed(node);
+ManglingError Remangler::mangleEscapingObjCBlock(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodesReversed(node, depth + 1));
   Buffer << "XL";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOwningAddressor(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "lO");
+ManglingError Remangler::mangleOwningAddressor(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "lO", depth + 1);
 }
 
-void Remangler::mangleOwningMutableAddressor(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "aO");
+ManglingError Remangler::mangleOwningMutableAddressor(Node *node,
+                                                      unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "aO", depth + 1);
 }
 
-void Remangler::manglePartialApplyForwarder(Node *node) {
-  mangleChildNodesReversed(node);
+ManglingError Remangler::manglePartialApplyForwarder(Node *node,
+                                                     unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodesReversed(node, depth + 1));
   Buffer << "TA";
+  return ManglingError::Success;
 }
 
-void Remangler::manglePartialApplyObjCForwarder(Node *node) {
-  mangleChildNodesReversed(node);
+ManglingError Remangler::manglePartialApplyObjCForwarder(Node *node,
+                                                         unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodesReversed(node, depth + 1));
   Buffer << "Ta";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleMergedFunction(Node *node) {
+ManglingError Remangler::mangleMergedFunction(Node *node, unsigned depth) {
   Buffer << "Tm";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDynamicallyReplaceableFunctionImpl(Node *node) {
+ManglingError
+Remangler::mangleDistributedThunk(Node *node, unsigned depth) {
+  Buffer << "TE";
+  return ManglingError::Success;
+}
+
+ManglingError
+Remangler::mangleDistributedAccessor(Node *node, unsigned depth) {
+  Buffer << "TF";
+  return ManglingError::Success;
+}
+
+ManglingError
+Remangler::mangleDynamicallyReplaceableFunctionImpl(Node *node,
+                                                    unsigned depth) {
   Buffer << "TI";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDynamicallyReplaceableFunctionKey(Node *node) {
+ManglingError
+Remangler::mangleDynamicallyReplaceableFunctionKey(Node *node, unsigned depth) {
   Buffer << "Tx";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDynamicallyReplaceableFunctionVar(Node *node) {
+ManglingError
+Remangler::mangleDynamicallyReplaceableFunctionVar(Node *node, unsigned depth) {
   Buffer << "TX";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAsyncAwaitResumePartialFunction(Node *node) {
+ManglingError Remangler::mangleAsyncAwaitResumePartialFunction(Node *node,
+                                                               unsigned depth) {
   Buffer << "TQ";
-  mangleChildNode(node, 0);
+  return mangleChildNode(node, 0, depth + 1);
 }
 
-void Remangler::mangleAsyncSuspendResumePartialFunction(Node *node) {
+ManglingError
+Remangler::mangleAsyncSuspendResumePartialFunction(Node *node, unsigned depth) {
   Buffer << "TY";
-  mangleChildNode(node, 0);
+  return mangleChildNode(node, 0, depth + 1);
 }
 
-void Remangler::manglePostfixOperator(Node *node) {
+ManglingError Remangler::manglePostfixOperator(Node *node, unsigned depth) {
   mangleIdentifierImpl(node, /*isOperator*/ true);
   Buffer << "oP";
+  return ManglingError::Success;
 }
 
-void Remangler::manglePrefixOperator(Node *node) {
+ManglingError Remangler::manglePrefixOperator(Node *node, unsigned depth) {
   mangleIdentifierImpl(node, /*isOperator*/ true);
   Buffer << "op";
+  return ManglingError::Success;
 }
 
-void Remangler::manglePrivateDeclName(Node *node) {
-  mangleChildNodesReversed(node);
+ManglingError Remangler::manglePrivateDeclName(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodesReversed(node, depth + 1));
   Buffer << (node->getNumChildren() == 1 ? "Ll" : "LL");
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocol(Node *node) {
-  mangleAnyGenericType(node, "P");
+ManglingError Remangler::mangleProtocol(Node *node, unsigned depth) {
+  return mangleAnyGenericType(node, "P", depth + 1);
 }
 
-void Remangler::mangleRetroactiveConformance(Node *node) {
-  mangleAnyProtocolConformance(node->getChild(1));
+ManglingError Remangler::mangleRetroactiveConformance(Node *node,
+                                                      unsigned depth) {
+  RETURN_IF_ERROR(mangleAnyProtocolConformance(node->getChild(1), depth + 1));
   Buffer << 'g';
   mangleIndex(node->getChild(0)->getIndex());
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolConformance(Node *node) {
+ManglingError Remangler::mangleProtocolConformance(Node *node, unsigned depth) {
   Node *Ty = getChildOfType(node->getChild(0));
   Node *GenSig = nullptr;
   if (Ty->getKind() == Node::Kind::DependentGenericType) {
     GenSig = Ty->getFirstChild();
     Ty = Ty->getChild(1);
   }
-  mangle(Ty);
+  RETURN_IF_ERROR(mangle(Ty, depth + 1));
   if (node->getNumChildren() == 4)
-    mangleChildNode(node, 3);
-  manglePureProtocol(node->getChild(1));
-  mangleChildNode(node, 2);
+    RETURN_IF_ERROR(mangleChildNode(node, 3, depth + 1));
+  RETURN_IF_ERROR(manglePureProtocol(node->getChild(1), depth + 1));
+  RETURN_IF_ERROR(mangleChildNode(node, 2, depth + 1));
   if (GenSig)
-    mangle(GenSig);
+    RETURN_IF_ERROR(mangle(GenSig, depth + 1));
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolConformanceRefInTypeModule(Node *node) {
-  manglePureProtocol(node->getChild(0));
+ManglingError
+Remangler::mangleProtocolConformanceRefInTypeModule(Node *node,
+                                                    unsigned depth) {
+  RETURN_IF_ERROR(manglePureProtocol(node->getChild(0), depth + 1));
   Buffer << "HP";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolConformanceRefInProtocolModule(Node *node) {
-  manglePureProtocol(node->getChild(0));
+ManglingError
+Remangler::mangleProtocolConformanceRefInProtocolModule(Node *node,
+                                                        unsigned depth) {
+  RETURN_IF_ERROR(manglePureProtocol(node->getChild(0), depth + 1));
   Buffer << "Hp";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolConformanceRefInOtherModule(Node *node) {
-  manglePureProtocol(node->getChild(0));
-  mangleChildNode(node, 1);
+ManglingError
+Remangler::mangleProtocolConformanceRefInOtherModule(Node *node,
+                                                     unsigned depth) {
+  RETURN_IF_ERROR(manglePureProtocol(node->getChild(0), depth + 1));
+  return mangleChildNode(node, 1, depth + 1);
 }
 
-void Remangler::mangleConcreteProtocolConformance(Node *node) {
-  mangleType(node->getChild(0));
-  mangle(node->getChild(1));
-  if (node->getNumChildren() > 2)
-    mangleAnyProtocolConformanceList(node->getChild(2));
-  else
+ManglingError Remangler::mangleConcreteProtocolConformance(Node *node,
+                                                           unsigned depth) {
+  RETURN_IF_ERROR(mangleType(node->getChild(0), depth + 1));
+  RETURN_IF_ERROR(mangle(node->getChild(1), depth + 1));
+  if (node->getNumChildren() > 2) {
+    RETURN_IF_ERROR(
+        mangleAnyProtocolConformanceList(node->getChild(2), depth + 1));
+  } else {
     Buffer << "y";
+  }
   Buffer << "HC";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDependentProtocolConformanceRoot(Node *node) {
-  mangleType(node->getChild(0));
-  manglePureProtocol(node->getChild(1));
+ManglingError Remangler::manglePackProtocolConformance(Node *node,
+                                                       unsigned depth) {
+  RETURN_IF_ERROR(
+      mangleAnyProtocolConformanceList(node->getChild(0), depth + 1));
+  Buffer << "HX";
+  return ManglingError::Success;
+}
+
+ManglingError
+Remangler::mangleDependentProtocolConformanceRoot(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleType(node->getChild(0), depth + 1));
+  RETURN_IF_ERROR(manglePureProtocol(node->getChild(1), depth + 1));
   Buffer << "HD";
-  mangleDependentConformanceIndex(node->getChild(2));
+  return mangleDependentConformanceIndex(node->getChild(2), depth + 1);
 }
 
-void Remangler::mangleDependentProtocolConformanceInherited(Node *node) {
-  mangleAnyProtocolConformance(node->getChild(0));
-  manglePureProtocol(node->getChild(1));
+ManglingError
+Remangler::mangleDependentProtocolConformanceInherited(Node *node,
+                                                       unsigned depth) {
+  RETURN_IF_ERROR(mangleAnyProtocolConformance(node->getChild(0), depth + 1));
+  RETURN_IF_ERROR(manglePureProtocol(node->getChild(1), depth + 1));
   Buffer << "HI";
-  mangleDependentConformanceIndex(node->getChild(2));
+  return mangleDependentConformanceIndex(node->getChild(2), depth + 1);
 }
 
-void Remangler::mangleDependentAssociatedConformance(Node *node) {
-  mangleType(node->getChild(0));
-  manglePureProtocol(node->getChild(1));
+ManglingError Remangler::mangleDependentAssociatedConformance(Node *node,
+                                                              unsigned depth) {
+  RETURN_IF_ERROR(mangleType(node->getChild(0), depth + 1));
+  return manglePureProtocol(node->getChild(1), depth + 1);
 }
 
-void Remangler::mangleDependentProtocolConformanceAssociated(Node *node) {
-  mangleAnyProtocolConformance(node->getChild(0));
-  mangleDependentAssociatedConformance(node->getChild(1));
+ManglingError
+Remangler::mangleDependentProtocolConformanceAssociated(Node *node,
+                                                        unsigned depth) {
+  RETURN_IF_ERROR(mangleAnyProtocolConformance(node->getChild(0), depth + 1));
+  RETURN_IF_ERROR(
+      mangleDependentAssociatedConformance(node->getChild(1), depth + 1));
   Buffer << "HA";
-  mangleDependentConformanceIndex(node->getChild(2));
+  return mangleDependentConformanceIndex(node->getChild(2), depth + 1);
 }
 
-void Remangler::mangleDependentConformanceIndex(Node *node) {
-  assert(node->getKind() == Node::Kind::Index ||
-         node->getKind() == Node::Kind::UnknownIndex);
-  assert(node->hasIndex() == (node->getKind() == Node::Kind::Index));
+ManglingError Remangler::mangleDependentConformanceIndex(Node *node,
+                                                         unsigned depth) {
+  DEMANGLER_ASSERT(node->getKind() == Node::Kind::Index ||
+                       node->getKind() == Node::Kind::UnknownIndex,
+                   node);
+  DEMANGLER_ASSERT(node->hasIndex() == (node->getKind() == Node::Kind::Index),
+                   node);
   mangleIndex(node->hasIndex() ? node->getIndex() + 2 : 1);
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAnyProtocolConformance(Node *node) {
+ManglingError Remangler::mangleAnyProtocolConformance(Node *node,
+                                                      unsigned depth) {
   switch (node->getKind()) {
   case Node::Kind::ConcreteProtocolConformance:
-    return mangleConcreteProtocolConformance(node);
+    return mangleConcreteProtocolConformance(node, depth + 1);
+  case Node::Kind::PackProtocolConformance:
+    return manglePackProtocolConformance(node, depth + 1);
   case Node::Kind::DependentProtocolConformanceRoot:
-    return mangleDependentProtocolConformanceRoot(node);
+    return mangleDependentProtocolConformanceRoot(node, depth + 1);
   case Node::Kind::DependentProtocolConformanceInherited:
-    return mangleDependentProtocolConformanceInherited(node);
+    return mangleDependentProtocolConformanceInherited(node, depth + 1);
   case Node::Kind::DependentProtocolConformanceAssociated:
-    return mangleDependentProtocolConformanceAssociated(node);
+    return mangleDependentProtocolConformanceAssociated(node, depth + 1);
   default:
-    break;
+    // Should this really succeed?!
+    return ManglingError::Success;
   }
 }
 
-void Remangler::mangleAnyProtocolConformanceList(Node *node) {
+ManglingError Remangler::mangleAnyProtocolConformanceList(Node *node,
+                                                          unsigned depth) {
   bool firstElem = true;
   for (NodePointer child : *node) {
-    mangleAnyProtocolConformance(child);
+    RETURN_IF_ERROR(mangleAnyProtocolConformance(child, depth + 1));
     mangleListSeparator(firstElem);
   }
   mangleEndOfList(firstElem);
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolDescriptor(Node *node) {
-  manglePureProtocol(getSingleChild(node));
+ManglingError Remangler::mangleProtocolDescriptor(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(manglePureProtocol(getSingleChild(node), depth + 1));
   Buffer << "Mp";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleProtocolDescriptorRecord(Node *node,
+                                                        unsigned depth) {
+  RETURN_IF_ERROR(manglePureProtocol(getSingleChild(node), depth + 1));
+  Buffer << "Hr";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolRequirementsBaseDescriptor(Node *node) {
-  manglePureProtocol(getSingleChild(node));
+ManglingError
+Remangler::mangleProtocolRequirementsBaseDescriptor(Node *node,
+                                                    unsigned depth) {
+  RETURN_IF_ERROR(manglePureProtocol(getSingleChild(node), depth + 1));
   Buffer << "TL";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolSelfConformanceDescriptor(Node *node) {
-  manglePureProtocol(node->getChild(0));
+ManglingError
+Remangler::mangleProtocolSelfConformanceDescriptor(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(manglePureProtocol(node->getChild(0), depth + 1));
   Buffer << "MS";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolConformanceDescriptor(Node *node) {
-  mangleProtocolConformance(node->getChild(0));
+ManglingError Remangler::mangleProtocolConformanceDescriptor(Node *node,
+                                                             unsigned depth) {
+  RETURN_IF_ERROR(mangleProtocolConformance(node->getChild(0), depth + 1));
   Buffer << "Mc";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolList(Node *node, Node *superclass,
-                                   bool hasExplicitAnyObject) {
+ManglingError
+Remangler::mangleProtocolConformanceDescriptorRecord(Node *node,
+                                                     unsigned depth) {
+  RETURN_IF_ERROR(mangleProtocolConformance(node->getChild(0), depth + 1));
+  Buffer << "Hc";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleProtocolList(Node *node, Node *superclass,
+                                            bool hasExplicitAnyObject,
+                                            unsigned depth) {
   auto *protocols = getSingleChild(node, Node::Kind::TypeList);
   bool FirstElem = true;
   for (NodePointer Child : *protocols) {
-    manglePureProtocol(Child);
+    RETURN_IF_ERROR(manglePureProtocol(Child, depth + 1));
     mangleListSeparator(FirstElem);
   }
   mangleEndOfList(FirstElem);
   if (superclass) {
-    mangleType(superclass);
+    RETURN_IF_ERROR(mangleType(superclass, depth + 1));
     Buffer << "Xc";
-    return;
+    return ManglingError::Success;
   } else if (hasExplicitAnyObject) {
     Buffer << "Xl";
-    return;
+    return ManglingError::Success;
   }
   Buffer << 'p';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolList(Node *node) {
-  mangleProtocolList(node, nullptr, false);
+ManglingError Remangler::mangleProtocolList(Node *node, unsigned depth) {
+  return mangleProtocolList(node, nullptr, false, depth + 1);
 }
 
-void Remangler::mangleProtocolListWithClass(Node *node) {
-  mangleProtocolList(node->getChild(0),
-                     node->getChild(1),
-                     false);
+ManglingError Remangler::mangleProtocolListWithClass(Node *node,
+                                                     unsigned depth) {
+  return mangleProtocolList(node->getChild(0), node->getChild(1), false,
+                            depth + 1);
 }
 
-void Remangler::mangleProtocolListWithAnyObject(Node *node) {
-  mangleProtocolList(node->getChild(0), nullptr, true);
+ManglingError Remangler::mangleProtocolListWithAnyObject(Node *node,
+                                                         unsigned depth) {
+  return mangleProtocolList(node->getChild(0), nullptr, true, depth + 1);
 }
 
-void Remangler::mangleProtocolSelfConformanceWitness(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleProtocolSelfConformanceWitness(Node *node,
+                                                              unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "TS";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolWitness(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleProtocolWitness(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "TW";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolSelfConformanceWitnessTable(Node *node) {
-  manglePureProtocol(node->getChild(0));
+ManglingError
+Remangler::mangleProtocolSelfConformanceWitnessTable(Node *node,
+                                                     unsigned depth) {
+  RETURN_IF_ERROR(manglePureProtocol(node->getChild(0), depth + 1));
   Buffer << "WS";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolWitnessTable(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleProtocolWitnessTable(Node *node,
+                                                    unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "WP";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolWitnessTablePattern(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleProtocolWitnessTablePattern(Node *node,
+                                                           unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Wp";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleProtocolWitnessTableAccessor(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleProtocolWitnessTableAccessor(Node *node,
+                                                            unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Wa";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleReabstractionThunk(Node *node) {
-  mangleChildNodesReversed(node);
+ManglingError Remangler::mangleReabstractionThunk(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodesReversed(node, depth + 1));
   Buffer << "Tr";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleReabstractionThunkHelper(Node *node) {
-  mangleChildNodesReversed(node);
+ManglingError Remangler::mangleReabstractionThunkHelper(Node *node,
+                                                        unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodesReversed(node, depth + 1));
   Buffer << "TR";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleReabstractionThunkHelperWithSelf(Node *node) {
-  mangleChildNodesReversed(node);
+ManglingError
+Remangler::mangleReabstractionThunkHelperWithSelf(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodesReversed(node, depth + 1));
   Buffer << "Ty";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleReabstractionThunkHelperWithGlobalActor(Node *node) {
-  mangleChildNodes(node);
+ManglingError
+Remangler::mangleReabstractionThunkHelperWithGlobalActor(Node *node,
+                                                         unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "TU";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAutoDiffFunctionOrSimpleThunk(Node *node, StringRef op) {
+ManglingError Remangler::mangleAutoDiffFunctionOrSimpleThunk(Node *node,
+                                                             StringRef op,
+                                                             unsigned depth) {
   auto childIt = node->begin();
   while (childIt != node->end() &&
          (*childIt)->getKind() != Node::Kind::AutoDiffFunctionKind)
-    mangle(*childIt++);
+    RETURN_IF_ERROR(mangle(*childIt++, depth + 1));
   Buffer << op;
-  mangle(*childIt++); // kind
-  mangle(*childIt++); // parameter indices
+  RETURN_IF_ERROR(mangle(*childIt++, depth + 1)); // kind
+  RETURN_IF_ERROR(mangle(*childIt++, depth + 1)); // parameter indices
   Buffer << 'p';
-  mangle(*childIt++); // result indices
+  RETURN_IF_ERROR(mangle(*childIt++, depth + 1)); // result indices
   Buffer << 'r';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAutoDiffFunction(Node *node) {
-  mangleAutoDiffFunctionOrSimpleThunk(node, "TJ");
+ManglingError Remangler::mangleAutoDiffFunction(Node *node, unsigned depth) {
+  return mangleAutoDiffFunctionOrSimpleThunk(node, "TJ", depth + 1);
 }
 
-void Remangler::mangleAutoDiffDerivativeVTableThunk(Node *node) {
-  mangleAutoDiffFunctionOrSimpleThunk(node, "TJV");
+ManglingError Remangler::mangleAutoDiffDerivativeVTableThunk(Node *node,
+                                                             unsigned depth) {
+  return mangleAutoDiffFunctionOrSimpleThunk(node, "TJV", depth + 1);
 }
 
-void Remangler::mangleAutoDiffSelfReorderingReabstractionThunk(Node *node) {
+ManglingError
+Remangler::mangleAutoDiffSelfReorderingReabstractionThunk(Node *node,
+                                                          unsigned depth) {
   auto childIt = node->begin();
-  mangle(*childIt++); // from type
-  mangle(*childIt++); // to type
+  RETURN_IF_ERROR(mangle(*childIt++, depth + 1)); // from type
+  RETURN_IF_ERROR(mangle(*childIt++, depth + 1)); // to type
   if ((*childIt)->getKind() == Node::Kind::DependentGenericSignature)
-    mangleDependentGenericSignature(*childIt++);
+    RETURN_IF_ERROR(mangleDependentGenericSignature(*childIt++, depth + 1));
   Buffer << "TJO";
-  mangle(*childIt++); // kind
+  return mangle(*childIt++, depth + 1); // kind
 }
 
-void Remangler::mangleAutoDiffSubsetParametersThunk(Node *node) {
+ManglingError Remangler::mangleAutoDiffSubsetParametersThunk(Node *node,
+                                                             unsigned depth) {
   auto childIt = node->begin();
   while (childIt != node->end() &&
          (*childIt)->getKind() != Node::Kind::AutoDiffFunctionKind)
-    mangle(*childIt++);
+    RETURN_IF_ERROR(mangle(*childIt++, depth + 1));
   Buffer << "TJS";
-  mangle(*childIt++); // kind
-  mangle(*childIt++); // parameter indices
+  RETURN_IF_ERROR(mangle(*childIt++, depth + 1)); // kind
+  RETURN_IF_ERROR(mangle(*childIt++, depth + 1)); // parameter indices
   Buffer << 'p';
-  mangle(*childIt++); // result indices
+  RETURN_IF_ERROR(mangle(*childIt++, depth + 1)); // result indices
   Buffer << 'r';
-  mangle(*childIt++); // to parameter indices
+  RETURN_IF_ERROR(mangle(*childIt++, depth + 1)); // to parameter indices
   Buffer << 'P';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAutoDiffFunctionKind(Node *node) {
+ManglingError Remangler::mangleAutoDiffFunctionKind(Node *node,
+                                                    unsigned depth) {
   Buffer << (char)node->getIndex();
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDifferentiabilityWitness(Node *node) {
+ManglingError Remangler::mangleDifferentiabilityWitness(Node *node,
+                                                        unsigned depth) {
   auto childIt = node->begin();
   while (childIt != node->end() && (*childIt)->getKind() != Node::Kind::Index)
-    mangle(*childIt++);
+    RETURN_IF_ERROR(mangle(*childIt++, depth + 1));
   if (node->getLastChild()->getKind() ==
           Node::Kind::DependentGenericSignature)
-    mangle(node->getLastChild());
+    RETURN_IF_ERROR(mangle(node->getLastChild(), depth + 1));
   Buffer << "WJ" << (char)(*childIt++)->getIndex();
-  mangle(*childIt++); // parameter indices
+  RETURN_IF_ERROR(mangle(*childIt++, depth + 1)); // parameter indices
   Buffer << 'p';
-  mangle(*childIt++); // result indices
+  RETURN_IF_ERROR(mangle(*childIt++, depth + 1)); // result indices
   Buffer << 'r';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleIndexSubset(Node *node) {
+ManglingError Remangler::mangleIndexSubset(Node *node, unsigned depth) {
   Buffer << node->getText();
+  return ManglingError::Success;
 }
 
-void Remangler::mangleReadAccessor(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "r");
+ManglingError Remangler::mangleReadAccessor(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "r", depth + 1);
 }
 
-void Remangler::mangleKeyPathThunkHelper(Node *node, StringRef op) {
+ManglingError Remangler::mangleKeyPathThunkHelper(Node *node, StringRef op,
+                                                  unsigned depth) {
   for (NodePointer Child : *node)
     if (Child->getKind() != Node::Kind::IsSerialized)
-      mangle(Child);
+      RETURN_IF_ERROR(mangle(Child, depth + 1));
   Buffer << op;
   for (NodePointer Child : *node)
     if (Child->getKind() == Node::Kind::IsSerialized)
-      mangle(Child);
+      RETURN_IF_ERROR(mangle(Child, depth + 1));
+  return ManglingError::Success;
 }
 
-void Remangler::mangleKeyPathGetterThunkHelper(Node *node) {
-  mangleKeyPathThunkHelper(node, "TK");
+ManglingError Remangler::mangleKeyPathGetterThunkHelper(Node *node,
+                                                        unsigned depth) {
+  return mangleKeyPathThunkHelper(node, "TK", depth + 1);
 }
 
-void Remangler::mangleKeyPathSetterThunkHelper(Node *node) {
-  mangleKeyPathThunkHelper(node, "Tk");
+ManglingError Remangler::mangleKeyPathSetterThunkHelper(Node *node,
+                                                        unsigned depth) {
+  return mangleKeyPathThunkHelper(node, "Tk", depth + 1);
 }
 
-void Remangler::mangleKeyPathEqualsThunkHelper(Node *node) {
-  mangleKeyPathThunkHelper(node, "TH");
+ManglingError Remangler::mangleKeyPathEqualsThunkHelper(Node *node,
+                                                        unsigned depth) {
+  return mangleKeyPathThunkHelper(node, "TH", depth + 1);
 }
 
-void Remangler::mangleKeyPathHashThunkHelper(Node *node) {
-  mangleKeyPathThunkHelper(node, "Th");
+ManglingError Remangler::mangleKeyPathHashThunkHelper(Node *node,
+                                                      unsigned depth) {
+  return mangleKeyPathThunkHelper(node, "Th", depth + 1);
 }
 
-void Remangler::mangleReturnType(Node *node) {
-  mangleArgumentTuple(node);
+ManglingError Remangler::mangleReturnType(Node *node, unsigned depth) {
+  return mangleArgumentTuple(node, depth + 1);
 }
 
-void Remangler::mangleRelatedEntityDeclName(Node *node) {
-  mangleChildNode(node, 1);
+ManglingError Remangler::mangleRelatedEntityDeclName(Node *node,
+                                                     unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
   NodePointer kindNode = node->getFirstChild();
   if (kindNode->getText().size() != 1)
-    unreachable("cannot handle multi-byte related entities");
+    return MANGLING_ERROR(ManglingError::MultiByteRelatedEntity, kindNode);
   Buffer << "L" << kindNode->getText();
+  return ManglingError::Success;
 }
 
-void Remangler::mangleSILBoxType(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleSILBoxType(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Xb";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleSetter(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "s");
+ManglingError Remangler::mangleSetter(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "s", depth + 1);
 }
 
-void Remangler::mangleSpecializationPassID(Node *node) {
+ManglingError Remangler::mangleSpecializationPassID(Node *node,
+                                                    unsigned depth) {
   Buffer << node->getIndex();
+  return ManglingError::Success;
 }
 
-void Remangler::mangleIsSerialized(Node *node) {
+ManglingError Remangler::mangleIsSerialized(Node *node, unsigned depth) {
   Buffer << 'q';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleStatic(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleAsyncRemoved(Node *node, unsigned depth) {
+  Buffer << 'a';
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleMetatypeParamsRemoved(Node *node, unsigned depth) {
+  Buffer << 'm';
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleStatic(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << 'Z';
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleOtherNominalType(Node *node, unsigned depth) {
+  return mangleAnyNominalType(node, depth + 1);
+}
+
+ManglingError Remangler::mangleStructure(Node *node, unsigned depth) {
+  return mangleAnyNominalType(node, depth + 1);
+}
+
+ManglingError Remangler::mangleSubscript(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node, "p", depth + 1);
 }
 
-void Remangler::mangleOtherNominalType(Node *node) {
-  mangleAnyNominalType(node);
+ManglingError Remangler::mangleMacro(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
+  Buffer << "fm";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleStructure(Node *node) {
-  mangleAnyNominalType(node);
+ManglingError Remangler::mangleFreestandingMacroExpansion(
+    Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
+  if (auto privateDiscriminator = node->getChild(3))
+    RETURN_IF_ERROR(mangle(privateDiscriminator, depth + 1));
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  Buffer << "fMf";
+  return mangleChildNode(node, 2, depth + 1);
+}
+
+#define FREESTANDING_MACRO_ROLE(Name, Description)
+#define ATTACHED_MACRO_ROLE(Name, Description, MangledChar)    \
+ManglingError Remangler::mangle##Name##AttachedMacroExpansion( \
+    Node *node, unsigned depth) {                              \
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));        \
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));        \
+  RETURN_IF_ERROR(mangleChildNode(node, 2, depth + 1));        \
+  Buffer << "fM" MangledChar;                                  \
+  return mangleChildNode(node, 3, depth + 1);                  \
+}
+#include "swift/Basic/MacroRoles.def"
+
+ManglingError Remangler::mangleMacroExpansionLoc(
+    Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+
+  auto line = node->getChild(2)->getIndex();
+  auto col = node->getChild(3)->getIndex();
+
+  Buffer << "fMX";
+  mangleIndex(line);
+  mangleIndex(col);
+
+  return ManglingError::Success;
 }
 
-void Remangler::mangleSubscript(Node *node) {
-  mangleAbstractStorage(node, "p");
+ManglingError Remangler::mangleMacroExpansionUniqueName(
+    Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
+  if (auto privateDiscriminator = node->getChild(3))
+    RETURN_IF_ERROR(mangle(privateDiscriminator, depth + 1));
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  Buffer << "fMu";
+  return mangleChildNode(node, 2, depth + 1);
 }
 
-void Remangler::mangleSuffix(Node *node) {
+ManglingError Remangler::mangleSuffix(Node *node, unsigned depth) {
   // Just add the suffix back on.
   Buffer << node->getText();
+  return ManglingError::Success;
 }
 
-void Remangler::mangleThinFunctionType(Node *node) {
-  mangleFunctionSignature(node);
+ManglingError Remangler::mangleThinFunctionType(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleFunctionSignature(node, depth + 1));
   Buffer << "Xf";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleTupleElement(Node *node) {
-  mangleChildNodesReversed(node); // tuple type, element name?
+ManglingError Remangler::mangleTupleElement(Node *node, unsigned depth) {
+  return mangleChildNodesReversed(node, depth + 1); // tuple type, element name?
 }
 
-void Remangler::mangleTupleElementName(Node *node) {
-  mangleIdentifier(node);
+ManglingError Remangler::mangleTupleElementName(Node *node, unsigned depth) {
+  return mangleIdentifier(node, depth + 1);
 }
 
-void Remangler::mangleType(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleType(Node *node, unsigned depth) {
+  return mangleSingleChildNode(node, depth + 1);
 }
 
-void Remangler::mangleTypeAlias(Node *node) {
-  mangleAnyNominalType(node);
+ManglingError Remangler::mangleTypeAlias(Node *node, unsigned depth) {
+  return mangleAnyNominalType(node, depth + 1);
 }
 
-void Remangler::mangleTypeList(Node *node) {
+ManglingError Remangler::mangleTypeList(Node *node, unsigned depth) {
   bool FirstElem = true;
   for (size_t Idx = 0, Num = node->getNumChildren(); Idx < Num; ++Idx) {
-    mangleChildNode(node, Idx);
+    RETURN_IF_ERROR(mangleChildNode(node, Idx, depth + 1));
     mangleListSeparator(FirstElem);
   }
   mangleEndOfList(FirstElem);
+  return ManglingError::Success;
 }
 
-void Remangler::mangleLabelList(Node *node) {
+ManglingError Remangler::mangleLabelList(Node *node, unsigned depth) {
   if (node->getNumChildren() == 0)
     Buffer << 'y';
   else
-    mangleChildNodes(node);
+    RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
+  return ManglingError::Success;
 }
 
-void Remangler::mangleTypeMangling(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleTypeMangling(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << 'D';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleTypeMetadata(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleTypeMetadata(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "N";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleTypeMetadataAccessFunction(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleTypeMetadataAccessFunction(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Ma";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleTypeMetadataInstantiationCache(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleTypeMetadataInstantiationCache(Node *node,
+                                                              unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "MI";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleTypeMetadataInstantiationFunction(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError
+Remangler::mangleTypeMetadataInstantiationFunction(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mi";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleTypeMetadataSingletonInitializationCache(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError
+Remangler::mangleTypeMetadataSingletonInitializationCache(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Ml";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleTypeMetadataCompletionFunction(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleTypeMetadataCompletionFunction(Node *node,
+                                                              unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mr";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleTypeMetadataDemanglingCache(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleTypeMetadataDemanglingCache(Node *node,
+                                                           unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "MD";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleTypeMetadataLazyCache(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleTypeMetadataLazyCache(Node *node,
+                                                     unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "ML";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleUncurriedFunctionType(Node *node) {
-  mangleFunctionSignature(node);
+ManglingError Remangler::mangleUncurriedFunctionType(Node *node,
+                                                     unsigned depth) {
+  RETURN_IF_ERROR(mangleFunctionSignature(node, depth + 1));
   // Mangle as regular function type (there is no "uncurried function type"
   // in the new mangling scheme).
   Buffer << 'c';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleUnsafeAddressor(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "lu");
+ManglingError Remangler::mangleUnsafeAddressor(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "lu", depth + 1);
 }
 
-void Remangler::mangleUnsafeMutableAddressor(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "au");
+ManglingError Remangler::mangleUnsafeMutableAddressor(Node *node,
+                                                      unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "au", depth + 1);
 }
 
-void Remangler::mangleValueWitness(Node *node) {
-  mangleChildNode(node, 1); // type
+ManglingError Remangler::mangleValueWitness(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1)); // type
   const char *Code = nullptr;
   switch (ValueWitnessKind(node->getFirstChild()->getIndex())) {
 #define VALUE_WITNESS(MANGLING, NAME) \
@@ -2392,192 +3263,345 @@ void Remangler::mangleValueWitness(Node *node) {
 #include "swift/Demangling/ValueWitnessMangling.def"
   }
   Buffer << 'w' << Code;
+  return ManglingError::Success;
 }
 
-void Remangler::mangleValueWitnessTable(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleValueWitnessTable(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "WV";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleVariable(Node *node) {
-  mangleAbstractStorage(node, "p");
+ManglingError Remangler::mangleVariable(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node, "p", depth + 1);
 }
 
-void Remangler::mangleVTableAttribute(Node *node) {
-  unreachable("Old-fashioned vtable thunk in new mangling format");
+ManglingError Remangler::mangleVTableAttribute(Node *node, unsigned depth) {
+  // Old-fashioned vtable thunk in new mangling format
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleVTableThunk(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleVTableThunk(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "TV";
+  return ManglingError::Success;
 }
 
-#define REF_STORAGE(Name, ...) \
-  void Remangler::mangle##Name(Node *node) { \
-    mangleSingleChildNode(node); \
-    Buffer << manglingOf(ReferenceOwnership::Name); \
+#define REF_STORAGE(Name, ...)                                                 \
+  ManglingError Remangler::mangle##Name(Node *node, unsigned depth) {          \
+    RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));                   \
+    Buffer << manglingOf(ReferenceOwnership::Name);                            \
+    return ManglingError::Success;                                             \
   }
 #include "swift/AST/ReferenceStorage.def"
 
-void Remangler::mangleWillSet(Node *node) {
-  mangleAbstractStorage(node->getFirstChild(), "w");
+ManglingError Remangler::mangleWillSet(Node *node, unsigned depth) {
+  return mangleAbstractStorage(node->getFirstChild(), "w", depth + 1);
 }
 
-void Remangler::mangleReflectionMetadataBuiltinDescriptor(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError
+Remangler::mangleReflectionMetadataBuiltinDescriptor(Node *node,
+                                                     unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "MB";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleReflectionMetadataFieldDescriptor(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError
+Remangler::mangleReflectionMetadataFieldDescriptor(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "MF";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleReflectionMetadataAssocTypeDescriptor(Node *node) {
-  mangleSingleChildNode(node); // protocol-conformance
+ManglingError
+Remangler::mangleReflectionMetadataAssocTypeDescriptor(Node *node,
+                                                       unsigned depth) {
+  RETURN_IF_ERROR(
+      mangleSingleChildNode(node, depth + 1)); // protocol-conformance
   Buffer << "MA";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleReflectionMetadataSuperclassDescriptor(Node *node) {
-  mangleSingleChildNode(node); // protocol-conformance
+ManglingError
+Remangler::mangleReflectionMetadataSuperclassDescriptor(Node *node,
+                                                        unsigned depth) {
+  RETURN_IF_ERROR(
+      mangleSingleChildNode(node, depth + 1)); // protocol-conformance
   Buffer << "MC";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleCurryThunk(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleCurryThunk(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Tc";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDispatchThunk(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleDispatchThunk(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Tj";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleMethodDescriptor(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleMethodDescriptor(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Tq";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleMethodLookupFunction(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleMethodLookupFunction(Node *node,
+                                                    unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mu";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleObjCMetadataUpdateFunction(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleObjCMetadataUpdateFunction(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "MU";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleObjCResilientClassStub(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleObjCResilientClassStub(Node *node,
+                                                      unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Ms";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleFullObjCResilientClassStub(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleFullObjCResilientClassStub(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mt";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleConcurrentFunctionType(Node *node) {
+ManglingError Remangler::mangleConcurrentFunctionType(Node *node,
+                                                      unsigned depth) {
   Buffer << "Yb";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAsyncAnnotation(Node *node) {
+ManglingError Remangler::mangleAsyncAnnotation(Node *node, unsigned depth) {
   Buffer << "Ya";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleDifferentiableFunctionType(Node *node) {
+ManglingError Remangler::mangleDifferentiableFunctionType(Node *node,
+                                                          unsigned depth) {
   Buffer << "Yj" << (char)node->getIndex(); // differentiability kind
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGlobalActorFunctionType(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleGlobalActorFunctionType(Node *node,
+                                                       unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "Yc";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleIsolatedAnyFunctionType(Node *node,
+                                                       unsigned depth) {
+  Buffer << "YA";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleSendingResultFunctionType(Node *node,
+                                                         unsigned depth) {
+  Buffer << "YT";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleThrowsAnnotation(Node *node) {
+ManglingError Remangler::mangleThrowsAnnotation(Node *node, unsigned depth) {
   Buffer << 'K';
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleTypedThrowsAnnotation(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
+  Buffer << "YK";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleEmptyList(Node *node) {
+ManglingError Remangler::mangleEmptyList(Node *node, unsigned depth) {
   Buffer << 'y';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleFirstElementMarker(Node *node) {
+ManglingError Remangler::mangleFirstElementMarker(Node *node, unsigned depth) {
   Buffer << '_';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleVariadicMarker(Node *node) {
+ManglingError Remangler::mangleVariadicMarker(Node *node, unsigned depth) {
   Buffer << 'd';
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOutlinedCopy(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleOutlinedCopy(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "WOy";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOutlinedConsume(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleOutlinedConsume(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "WOe";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOutlinedRetain(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleOutlinedRetain(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "WOr";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOutlinedRelease(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleOutlinedRelease(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "WOs";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOutlinedInitializeWithTake(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleOutlinedInitializeWithTake(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "WOb";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOutlinedInitializeWithCopy(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleOutlinedInitializeWithCopy(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "WOc";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOutlinedAssignWithTake(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleOutlinedAssignWithTake(Node *node,
+                                                      unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "WOd";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOutlinedAssignWithCopy(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleOutlinedAssignWithCopy(Node *node,
+                                                      unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "WOf";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOutlinedDestroy(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleOutlinedDestroy(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "WOh";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleOutlinedInitializeWithCopyNoValueWitness(Node *node,
+                                                                        unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
+  Buffer << "WOC";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOutlinedVariable(Node *node) {
+ManglingError Remangler::mangleOutlinedAssignWithTakeNoValueWitness(Node *node,
+                                                                    unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
+  Buffer << "WOD";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleOutlinedAssignWithCopyNoValueWitness(Node *node,
+                                                                    unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
+  Buffer << "WOF";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleOutlinedDestroyNoValueWitness(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
+  Buffer << "WOH";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleOutlinedEnumGetTag(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
+  Buffer << "WOg";
+  return ManglingError::Success;
+}
+ManglingError Remangler::mangleOutlinedEnumProjectDataForLoad(Node *node, unsigned depth) {
+  if (node->getNumChildren() == 2) {
+    auto ty = node->getChild(0);
+    RETURN_IF_ERROR(mangle(ty, depth + 1));
+    Buffer << "WOj";
+    mangleIndex(node->getChild(1)->getIndex());
+    return ManglingError::Success;
+  } else {
+    auto ty = node->getChild(0);
+    RETURN_IF_ERROR(mangle(ty, depth + 1));
+    auto sig = node->getChild(1);
+    RETURN_IF_ERROR(mangle(sig, depth + 1));
+    Buffer << "WOj";
+    mangleIndex(node->getChild(2)->getIndex());
+    return ManglingError::Success;
+  }
+}
+ManglingError Remangler::mangleOutlinedEnumTagStore(Node *node, unsigned depth) {
+  if (node->getNumChildren() == 2) {
+    auto ty = node->getChild(0);
+    RETURN_IF_ERROR(mangle(ty, depth + 1));
+    Buffer << "WOi";
+    mangleIndex(node->getChild(1)->getIndex());
+    return ManglingError::Success;
+  } else {
+    auto ty = node->getChild(0);
+    RETURN_IF_ERROR(mangle(ty, depth + 1));
+    auto sig = node->getChild(1);
+    RETURN_IF_ERROR(mangle(sig, depth + 1));
+    Buffer << "WOi";
+    mangleIndex(node->getChild(2)->getIndex());
+    return ManglingError::Success;
+  }
+}
+ManglingError Remangler::mangleOutlinedVariable(Node *node, unsigned depth) {
   Buffer << "Tv";
   mangleIndex(node->getIndex());
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOutlinedBridgedMethod(Node *node) {
+ManglingError Remangler::mangleOutlinedReadOnlyObject(Node *node, unsigned depth) {
+  Buffer << "Tv";
+  mangleIndex(node->getIndex());
+  Buffer << 'r';
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleOutlinedBridgedMethod(Node *node,
+                                                     unsigned depth) {
   Buffer << "Te";
   Buffer << node->getText();
   Buffer << "_";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleSILBoxTypeWithLayout(Node *node) {
-  assert(node->getNumChildren() == 1 || node->getNumChildren() == 3);
-  assert(node->getChild(0)->getKind() == Node::Kind::SILBoxLayout);
+ManglingError Remangler::mangleSILBoxTypeWithLayout(Node *node,
+                                                    unsigned depth) {
+  DEMANGLER_ASSERT(node->getNumChildren() == 1 || node->getNumChildren() == 3,
+                   node);
+  DEMANGLER_ASSERT(node->getChild(0)->getKind() == Node::Kind::SILBoxLayout,
+                   node);
   auto layout = node->getChild(0);
   auto layoutTypeList = Factory.createNode(Node::Kind::TypeList);
   for (unsigned i = 0, e = layout->getNumChildren(); i < e; ++i) {
-    assert(layout->getChild(i)->getKind() == Node::Kind::SILBoxImmutableField
-           || layout->getChild(i)->getKind() == Node::Kind::SILBoxMutableField);
+    DEMANGLER_ASSERT(
+        layout->getChild(i)->getKind() == Node::Kind::SILBoxImmutableField ||
+            layout->getChild(i)->getKind() == Node::Kind::SILBoxMutableField,
+        layout->getChild(i));
     auto field = layout->getChild(i);
-    assert(field->getNumChildren() == 1
-           && field->getChild(0)->getKind() == Node::Kind::Type);
+    DEMANGLER_ASSERT(field->getNumChildren() == 1 &&
+                         field->getChild(0)->getKind() == Node::Kind::Type,
+                     field);
     auto fieldType = field->getChild(0);
     // 'inout' mangling is used to represent mutable fields.
     if (field->getKind() == Node::Kind::SILBoxMutableField) {
@@ -2588,218 +3612,376 @@ void Remangler::mangleSILBoxTypeWithLayout(Node *node) {
     }
     layoutTypeList->addChild(fieldType, Factory);
   }
-  mangleTypeList(layoutTypeList);
-  
+  RETURN_IF_ERROR(mangleTypeList(layoutTypeList, depth + 1));
+
   if (node->getNumChildren() == 3) {
     auto signature = node->getChild(1);
     auto genericArgs = node->getChild(2);
-    assert(signature->getKind() == Node::Kind::DependentGenericSignature);
-    assert(genericArgs->getKind() == Node::Kind::TypeList);
-    mangleTypeList(genericArgs);
-    mangleDependentGenericSignature(signature);
+    DEMANGLER_ASSERT(
+        signature->getKind() == Node::Kind::DependentGenericSignature, node);
+    DEMANGLER_ASSERT(genericArgs->getKind() == Node::Kind::TypeList, node);
+    RETURN_IF_ERROR(mangleTypeList(genericArgs, depth + 1));
+    RETURN_IF_ERROR(mangleDependentGenericSignature(signature, depth + 1));
     Buffer << "XX";
   } else {
     Buffer << "Xx";
   }
+  return ManglingError::Success;
 }
 
-void Remangler::mangleSILBoxLayout(Node *node) {
-  unreachable("should be part of SILBoxTypeWithLayout");
+ManglingError Remangler::mangleSILBoxLayout(Node *node, unsigned depth) {
+  // should be part of SILBoxTypeWithLayout
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleSILBoxMutableField(Node *node) {
-  unreachable("should be part of SILBoxTypeWithLayout");
+ManglingError Remangler::mangleSILBoxMutableField(Node *node, unsigned depth) {
+  // should be part of SILBoxTypeWithLayout
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleSILBoxImmutableField(Node *node) {
-  unreachable("should be part of SILBoxTypeWithLayout");
+ManglingError Remangler::mangleSILBoxImmutableField(Node *node,
+                                                    unsigned depth) {
+  // should be part of SILBoxTypeWithLayout
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleAssocTypePath(Node *node) {
+ManglingError Remangler::mangleAssocTypePath(Node *node, unsigned depth) {
   bool FirstElem = true;
   for (NodePointer Child : *node) {
-    mangle(Child);
+    RETURN_IF_ERROR(mangle(Child, depth + 1));
     mangleListSeparator(FirstElem);
   }
+  return ManglingError::Success;
 }
-  
-void Remangler::mangleModuleDescriptor(Node *node) {
-  mangle(node->getChild(0));
+
+ManglingError Remangler::mangleModuleDescriptor(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangle(node->getChild(0), depth + 1));
   Buffer << "MXM";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleExtensionDescriptor(Node *node) {
-  mangle(node->getChild(0));
+ManglingError Remangler::mangleExtensionDescriptor(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangle(node->getChild(0), depth + 1));
   Buffer << "MXE";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleAnonymousDescriptor(Node *node) {
-  mangle(node->getChild(0));
+ManglingError Remangler::mangleAnonymousDescriptor(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangle(node->getChild(0), depth + 1));
   if (node->getNumChildren() == 1) {
     Buffer << "MXX";
   } else {
-    mangleIdentifier(node->getChild(1));
+    RETURN_IF_ERROR(mangleIdentifier(node->getChild(1), depth + 1));
     Buffer << "MXY";
   }
+  return ManglingError::Success;
 }
-  
-void Remangler::mangleAssociatedTypeGenericParamRef(Node *node) {
-  mangleType(node->getChild(0));
-  mangleAssocTypePath(node->getChild(1));
+
+ManglingError Remangler::mangleAssociatedTypeGenericParamRef(Node *node,
+                                                             unsigned depth) {
+  RETURN_IF_ERROR(mangleType(node->getChild(0), depth + 1));
+  RETURN_IF_ERROR(mangleAssocTypePath(node->getChild(1), depth + 1));
   Buffer << "MXA";
+  return ManglingError::Success;
 }
-  
-void Remangler::mangleTypeSymbolicReference(Node *node) {
-  return mangle(Resolver(SymbolicReferenceKind::Context,
-                         (const void *)node->getIndex()));
+
+ManglingError Remangler::mangleTypeSymbolicReference(Node *node,
+                                                     unsigned depth) {
+  return mangle(
+      Resolver(SymbolicReferenceKind::Context, (const void *)node->getIndex()),
+      depth + 1);
+}
+
+ManglingError
+Remangler::mangleObjectiveCProtocolSymbolicReference(Node *node,
+                                                     unsigned depth) {
+  return mangle(Resolver(SymbolicReferenceKind::ObjectiveCProtocol,
+                         (const void *)node->getIndex()),
+                depth + 1);
 }
 
-void Remangler::mangleProtocolSymbolicReference(Node *node) {
-  return mangle(Resolver(SymbolicReferenceKind::Context,
-                         (const void *)node->getIndex()));
+ManglingError Remangler::mangleProtocolSymbolicReference(Node *node,
+                                                         unsigned depth) {
+  return mangle(
+      Resolver(SymbolicReferenceKind::Context, (const void *)node->getIndex()),
+      depth + 1);
 }
 
-void Remangler::mangleOpaqueTypeDescriptorSymbolicReference(Node *node) {
-  return mangle(Resolver(SymbolicReferenceKind::Context,
-                         (const void *)node->getIndex()));
+ManglingError
+Remangler::mangleOpaqueTypeDescriptorSymbolicReference(Node *node,
+                                                       unsigned depth) {
+  return mangle(
+      Resolver(SymbolicReferenceKind::Context, (const void *)node->getIndex()),
+      depth + 1);
 }
 
-void Remangler::mangleSugaredOptional(Node *node) {
-  mangleType(node->getChild(0));
+ManglingError Remangler::mangleSugaredOptional(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleType(node->getChild(0), depth + 1));
   Buffer << "XSq";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleSugaredArray(Node *node) {
-  mangleType(node->getChild(0));
+ManglingError Remangler::mangleSugaredArray(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleType(node->getChild(0), depth + 1));
   Buffer << "XSa";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleSugaredDictionary(Node *node) {
-  mangleType(node->getChild(0));
-  mangleType(node->getChild(1));
+ManglingError Remangler::mangleSugaredDictionary(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleType(node->getChild(0), depth + 1));
+  RETURN_IF_ERROR(mangleType(node->getChild(1), depth + 1));
   Buffer << "XSD";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleSugaredParen(Node *node) {
-  mangleType(node->getChild(0));
+ManglingError Remangler::mangleSugaredParen(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleType(node->getChild(0), depth + 1));
   Buffer << "XSp";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleOpaqueReturnType(Node *node) {
+ManglingError Remangler::mangleOpaqueReturnType(Node *node, unsigned depth) {
+  if (node->hasChildren()
+      && node->getFirstChild()->getKind() == Node::Kind::OpaqueReturnTypeIndex) {
+    Buffer << "QR";
+    mangleIndex(node->getFirstChild()->getIndex());
+    return ManglingError::Success;
+  }
   Buffer << "Qr";
+  return ManglingError::Success;
+}
+ManglingError Remangler::mangleOpaqueReturnTypeIndex(Node *node, unsigned depth) {
+  // Cannot appear unparented to an OpaqueReturnType.
+  return ManglingError::WrongNodeType;
+}
+ManglingError Remangler::mangleOpaqueReturnTypeParent(Node *node, unsigned depth) {
+  // Cannot appear unparented to an OpaqueReturnType.
+  return ManglingError::WrongNodeType;
 }
-void Remangler::mangleOpaqueReturnTypeOf(Node *node) {
-  mangle(node->getChild(0));
+ManglingError Remangler::mangleOpaqueReturnTypeOf(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangle(node->getChild(0), depth + 1));
   Buffer << "QO";
+  return ManglingError::Success;
 }
-void Remangler::mangleOpaqueType(Node *node) {
+ManglingError Remangler::mangleOpaqueType(Node *node, unsigned depth) {
   SubstitutionEntry entry;
-  if (trySubstitution(node, entry)) return;
+  if (trySubstitution(node, entry))
+    return ManglingError::Success;
 
-  mangle(node->getChild(0));
+  DEMANGLER_ASSERT(node->getNumChildren() >= 3, node);
+  RETURN_IF_ERROR(mangle(node->getChild(0), depth + 1));
   auto boundGenerics = node->getChild(2);
   for (unsigned i = 0; i < boundGenerics->getNumChildren(); ++i) {
     Buffer << (i == 0 ? 'y' : '_');
-    mangleChildNodes(boundGenerics->getChild(i));
+    RETURN_IF_ERROR(mangleChildNodes(boundGenerics->getChild(i), depth + 1));
   }
   if (node->getNumChildren() >= 4) {
     auto retroactiveConformances = node->getChild(3);
     for (unsigned i = 0; i < retroactiveConformances->getNumChildren(); ++i) {
-      mangle(retroactiveConformances->getChild(i));
+      RETURN_IF_ERROR(mangle(retroactiveConformances->getChild(i), depth + 1));
     }
   }
   Buffer << "Qo";
   mangleIndex(node->getChild(1)->getIndex());
 
   addSubstitution(entry);
+  return ManglingError::Success;
 }
-void Remangler::mangleAccessorFunctionReference(Node *node) {
-  unreachable("can't remangle");
+ManglingError Remangler::mangleAccessorFunctionReference(Node *node,
+                                                         unsigned depth) {
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
-void Remangler::mangleCanonicalSpecializedGenericMetaclass(Node *node) {
-  mangleChildNodes(node);
+ManglingError
+Remangler::mangleCanonicalSpecializedGenericMetaclass(Node *node,
+                                                      unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "MM";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleCanonicalSpecializedGenericTypeMetadataAccessFunction(
-    Node *node) {
-  mangleSingleChildNode(node);
+ManglingError
+Remangler::mangleCanonicalSpecializedGenericTypeMetadataAccessFunction(
+    Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mb";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleMetadataInstantiationCache(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleMetadataInstantiationCache(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "MK";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleNoncanonicalSpecializedGenericTypeMetadata(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError
+Remangler::mangleNoncanonicalSpecializedGenericTypeMetadata(Node *node,
+                                                            unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "MN";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleNoncanonicalSpecializedGenericTypeMetadataCache(Node *node) {
-  mangleSingleChildNode(node);
+ManglingError Remangler::mangleNoncanonicalSpecializedGenericTypeMetadataCache(
+    Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "MJ";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleCanonicalPrespecializedGenericTypeCachingOnceToken(
-    Node *node) {
-  mangleSingleChildNode(node);
+ManglingError
+Remangler::mangleCanonicalPrespecializedGenericTypeCachingOnceToken(
+    Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Mz";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGlobalVariableOnceToken(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleGlobalVariableOnceToken(Node *node,
+                                                       unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "Wz";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGlobalVariableOnceFunction(Node *node) {
-  mangleChildNodes(node);
+ManglingError Remangler::mangleGlobalVariableOnceFunction(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
   Buffer << "WZ";
+  return ManglingError::Success;
 }
 
-void Remangler::mangleGlobalVariableOnceDeclList(Node *node) {
+ManglingError Remangler::mangleGlobalVariableOnceDeclList(Node *node,
+                                                          unsigned depth) {
   for (unsigned i = 0, e = node->getNumChildren(); i < e; ++i) {
-    mangle(node->getChild(i));
+    RETURN_IF_ERROR(mangle(node->getChild(i), depth + 1));
     Buffer << '_';
   }
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleAccessibleFunctionRecord(Node *node,
+                                                        unsigned depth) {
+  Buffer << "HF";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleBackDeploymentThunk(Node *node,
+                                                   unsigned depth) {
+  Buffer << "Twb";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleBackDeploymentFallback(Node *node,
+                                                      unsigned depth) {
+  Buffer << "TwB";
+  return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleUniquable(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangle(node->getChild(0), depth + 1));
+  Buffer << "Mq";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleExtendedExistentialTypeShape(Node *node,
+                                                            unsigned depth) {
+  NodePointer genSig, type;
+  if (node->getNumChildren() == 1) {
+    genSig = nullptr;
+    type = node->getChild(0);
+  } else {
+    genSig = node->getChild(0);
+    type = node->getChild(1);
+  }
+
+  if (genSig) {
+    RETURN_IF_ERROR(mangle(genSig, depth + 1));  
+  }
+  RETURN_IF_ERROR(mangle(type, depth + 1));
+
+  if (genSig)
+    Buffer << "XG";
+  else
+    Buffer << "Xg";
+
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleHasSymbolQuery(Node *node, unsigned depth) {
+  Buffer << "TwS";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleSymbolicExtendedExistentialType(Node *node,
+                                                     unsigned int depth) {
+  RETURN_IF_ERROR(mangle(node->getChild(0), depth+1));
+  for (auto arg: *node->getChild(1))
+    RETURN_IF_ERROR(mangle(arg, depth+1));
+  if (node->getNumChildren() > 2)
+    for (auto conf: *node->getChild(2))
+      RETURN_IF_ERROR(mangle(conf, depth+1));
+  return ManglingError::Success;
+}
+ManglingError Remangler::
+mangleUniqueExtendedExistentialTypeShapeSymbolicReference(Node *node,
+                                                     unsigned int depth) {
+  // We don't support absolute references in the mangling of these
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
+}
+ManglingError Remangler::
+mangleNonUniqueExtendedExistentialTypeShapeSymbolicReference(Node *node,
+                                                     unsigned int depth) {
+  // We don't support absolute references in the mangling of these
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
+}
 } // anonymous namespace
 
 /// The top-level interface to the remangler.
-std::string Demangle::mangleNode(NodePointer node) {
+ManglingErrorOr<std::string> Demangle::mangleNode(NodePointer node) {
   return mangleNode(node, [](SymbolicReferenceKind, const void *) -> NodePointer {
-    unreachable("should not try to mangle a symbolic reference; "
-                "resolve it to a non-symbolic demangling tree instead");
-  });
+                            return nullptr;
+                          });
+  //  unreachable("should not try to mangle a symbolic reference; "
+  //              "resolve it to a non-symbolic demangling tree instead");
 }
 
-std::string
+ManglingErrorOr<std::string>
 Demangle::mangleNode(NodePointer node, SymbolicResolver resolver) {
-  if (!node) return "";
+  if (!node) return std::string();
 
   NodeFactory Factory;
   Remangler remangler(resolver, Factory);
-  remangler.mangle(node);
+  ManglingError err = remangler.mangle(node, 0);
+  if (!err.isSuccess())
+    return err;
 
   return remangler.str();
 }
 
-llvm::StringRef
+ManglingErrorOr<llvm::StringRef>
 Demangle::mangleNode(NodePointer node, SymbolicResolver resolver,
                      NodeFactory &Factory) {
   if (!node)
     return StringRef();
 
   Remangler remangler(resolver, Factory);
-  remangler.mangle(node);
+  ManglingError err = remangler.mangle(node, 0);
+  if (!err.isSuccess())
+    return err;
 
   return remangler.getBufferStr();
 }
 
 bool Demangle::isSpecialized(Node *node) {
+  // We shouldn't get here with node being NULL; if we do, assert in debug,
+  // or return false at runtime (which should at least help diagnose things
+  // further if it happens).
+  assert(node);
+  if (!node)
+    return false;
+
   switch (node->getKind()) {
     case Node::Kind::BoundGenericStructure:
     case Node::Kind::BoundGenericEnum:
@@ -2808,6 +3990,7 @@ bool Demangle::isSpecialized(Node *node) {
     case Node::Kind::BoundGenericTypeAlias:
     case Node::Kind::BoundGenericProtocol:
     case Node::Kind::BoundGenericFunction:
+    case Node::Kind::ConstrainedExistential:
       return true;
 
     case Node::Kind::Structure:
@@ -2836,17 +4019,21 @@ bool Demangle::isSpecialized(Node *node) {
     case Node::Kind::ModifyAccessor:
     case Node::Kind::UnsafeAddressor:
     case Node::Kind::UnsafeMutableAddressor:
-      return isSpecialized(node->getChild(0));
+    case Node::Kind::Static:
+      assert(node->getNumChildren() > 0);
+      return node->getNumChildren() > 0 && isSpecialized(node->getChild(0));
 
     case Node::Kind::Extension:
-      return isSpecialized(node->getChild(1));
+      assert(node->getNumChildren() > 1);
+      return node->getNumChildren() > 1 && isSpecialized(node->getChild(1));
 
     default:
       return false;
   }
 }
 
-NodePointer Demangle::getUnspecialized(Node *node, NodeFactory &Factory) {
+ManglingErrorOr<NodePointer> Demangle::getUnspecialized(Node *node,
+                                                        NodeFactory &Factory) {
   unsigned NumToCopy = 2;
   switch (node->getKind()) {
     case Node::Kind::Function:
@@ -2869,6 +4056,7 @@ NodePointer Demangle::getUnspecialized(Node *node, NodeFactory &Factory) {
     case Node::Kind::PropertyWrapperBackingInitializer:
     case Node::Kind::PropertyWrapperInitFromProjectedValue:
     case Node::Kind::DefaultArgumentInitializer:
+    case Node::Kind::Static:
       NumToCopy = node->getNumChildren();
       LLVM_FALLTHROUGH;
     case Node::Kind::Structure:
@@ -2877,9 +4065,15 @@ NodePointer Demangle::getUnspecialized(Node *node, NodeFactory &Factory) {
     case Node::Kind::TypeAlias:
     case Node::Kind::OtherNominalType: {
       NodePointer result = Factory.createNode(node->getKind());
+
+      DEMANGLER_ASSERT(node->hasChildren(), node);
       NodePointer parentOrModule = node->getChild(0);
-      if (isSpecialized(parentOrModule))
-        parentOrModule = getUnspecialized(parentOrModule, Factory);
+      if (isSpecialized(parentOrModule)) {
+        auto unspec = getUnspecialized(parentOrModule, Factory);
+        if (!unspec.isSuccess())
+          return unspec;
+        parentOrModule = unspec.result();
+      }
       result->addChild(parentOrModule, Factory);
       for (unsigned Idx = 1; Idx < NumToCopy; ++Idx) {
         result->addChild(node->getChild(Idx), Factory);
@@ -2893,30 +4087,46 @@ NodePointer Demangle::getUnspecialized(Node *node, NodeFactory &Factory) {
     case Node::Kind::BoundGenericProtocol:
     case Node::Kind::BoundGenericOtherNominalType:
     case Node::Kind::BoundGenericTypeAlias: {
+      DEMANGLER_ASSERT(node->hasChildren(), node);
       NodePointer unboundType = node->getChild(0);
-      assert(unboundType->getKind() == Node::Kind::Type);
+      DEMANGLER_ASSERT(unboundType->getKind() == Node::Kind::Type, unboundType);
+      DEMANGLER_ASSERT(unboundType->hasChildren(), unboundType);
       NodePointer nominalType = unboundType->getChild(0);
       if (isSpecialized(nominalType))
         return getUnspecialized(nominalType, Factory);
       return nominalType;
     }
 
+    case Node::Kind::ConstrainedExistential: {
+      DEMANGLER_ASSERT(node->hasChildren(), node);
+      NodePointer unboundType = node->getChild(0);
+      DEMANGLER_ASSERT(unboundType->getKind() == Node::Kind::Type, unboundType);
+      return unboundType;
+    }
+
     case Node::Kind::BoundGenericFunction: {
+      DEMANGLER_ASSERT(node->hasChildren(), node);
       NodePointer unboundFunction = node->getChild(0);
-      assert(unboundFunction->getKind() == Node::Kind::Function ||
-             unboundFunction->getKind() == Node::Kind::Constructor);
+      DEMANGLER_ASSERT(unboundFunction->getKind() == Node::Kind::Function ||
+                           unboundFunction->getKind() ==
+                               Node::Kind::Constructor,
+                       unboundFunction);
       if (isSpecialized(unboundFunction))
         return getUnspecialized(unboundFunction, Factory);
       return unboundFunction;
     }
 
     case Node::Kind::Extension: {
+      DEMANGLER_ASSERT(node->getNumChildren() >= 2, node);
       NodePointer parent = node->getChild(1);
       if (!isSpecialized(parent))
         return node;
+      auto unspec = getUnspecialized(parent, Factory);
+      if (!unspec.isSuccess())
+        return unspec.error();
       NodePointer result = Factory.createNode(Node::Kind::Extension);
       result->addChild(node->getFirstChild(), Factory);
-      result->addChild(getUnspecialized(parent, Factory), Factory);
+      result->addChild(unspec.result(), Factory);
       if (node->getNumChildren() == 3) {
         // Add the generic signature of the extension.
         result->addChild(node->getChild(2), Factory);
@@ -2924,6 +4134,6 @@ NodePointer Demangle::getUnspecialized(Node *node, NodeFactory &Factory) {
       return result;
     }
     default:
-      unreachable("bad nominal type kind");
+      return MANGLING_ERROR(ManglingError::BadNominalTypeKind, node);
   }
 }
diff --git a/symbolic-demangle/vendor/swift/lib/Demangling/RemanglerBase.h b/symbolic-demangle/vendor/swift/lib/Demangling/RemanglerBase.h
index a98467fea..7a6a4fe9f 100644
--- a/symbolic-demangle/vendor/swift/lib/Demangling/RemanglerBase.h
+++ b/symbolic-demangle/vendor/swift/lib/Demangling/RemanglerBase.h
@@ -28,6 +28,13 @@ namespace swift {
 namespace Demangle {
 SWIFT_BEGIN_INLINE_NAMESPACE
 
+#define RETURN_IF_ERROR(x)                                                     \
+  do {                                                                         \
+    ManglingError err = (x);                                                   \
+    if (!err.isSuccess())                                                      \
+      return err;                                                              \
+  } while (0)
+
 // An entry in the remangler's substitution map.
 class SubstitutionEntry {
   Node *TheNode = nullptr;
@@ -35,10 +42,10 @@ class SubstitutionEntry {
   bool treatAsIdentifier = false;
 
 public:
-  void setNode(Node *node, bool treatAsIdentifier) {
+  void setNode(Node *node, bool treatAsIdentifier, size_t hash) {
     this->treatAsIdentifier = treatAsIdentifier;
     TheNode = node;
-    deepHash(node);
+    StoredHash = hash;
   }
 
   struct Hasher {
@@ -47,6 +54,14 @@ class SubstitutionEntry {
     }
   };
 
+  bool isEmpty() const { return !TheNode; }
+
+  bool matches(Node *node, bool treatAsIdentifier) const {
+    return node == TheNode && treatAsIdentifier == this->treatAsIdentifier;
+  }
+
+  size_t hash() const { return StoredHash; }
+
 private:
   friend bool operator==(const SubstitutionEntry &lhs,
                          const SubstitutionEntry &rhs) {
@@ -62,12 +77,6 @@ class SubstitutionEntry {
 
   static bool identifierEquals(Node *lhs, Node *rhs);
 
-  void combineHash(size_t newValue) {
-    StoredHash = 33 * StoredHash + newValue;
-  }
-
-  void deepHash(Node *node);
-
   bool deepEquals(Node *lhs, Node *rhs) const;
 };
 
@@ -124,6 +133,13 @@ class RemanglerBase {
   // Used to allocate temporary nodes and the output string (in Buffer).
   NodeFactory &Factory;
 
+  // Recursively calculating the node hashes can be expensive if the node tree
+  // is deep, so we keep a hash table mapping (Node *, treatAsIdentifier) pairs
+  // to hashes.
+  static const size_t HashHashCapacity = 512; // Must be a power of 2
+  static const size_t HashHashMaxProbes = 8;
+  SubstitutionEntry HashHash[HashHashCapacity] = {};
+
   // An efficient hash-map implementation in the spirit of llvm's SmallPtrSet:
   // The first 16 substitutions are stored in an inline-allocated array to avoid
   // malloc calls in the common case.
@@ -141,7 +157,16 @@ class RemanglerBase {
   RemanglerBuffer Buffer;
 
 protected:
-  RemanglerBase(NodeFactory &Factory) : Factory(Factory), Buffer(Factory) { }
+  RemanglerBase(NodeFactory &Factory)
+    : Factory(Factory), Buffer(Factory) { }
+
+  /// Compute the hash for a node.
+  size_t hashForNode(Node *node, bool treatAsIdentifier = false);
+
+  /// Construct a SubstitutionEntry for a given node.
+  /// This will look in the HashHash to see if we already know the hash,
+  /// to avoid having to walk the entire subtree.
+  SubstitutionEntry entryForNode(Node *node, bool treatAsIdentifier = false);
 
   /// Find a substitution and return its index.
   /// Returns -1 if no substitution is found.
diff --git a/symbolic-demangle/vendor/swift/stdlib/public/SwiftShims/Visibility.h b/symbolic-demangle/vendor/swift/stdlib/public/SwiftShims/Visibility.h
deleted file mode 100644
index deeec91d2..000000000
--- a/symbolic-demangle/vendor/swift/stdlib/public/SwiftShims/Visibility.h
+++ /dev/null
@@ -1,269 +0,0 @@
-//===--- Visibility.h - Visibility macros for runtime exports ---*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-//  These macros are used to declare symbols that should be exported from the
-//  Swift runtime.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef SWIFT_STDLIB_SHIMS_VISIBILITY_H
-#define SWIFT_STDLIB_SHIMS_VISIBILITY_H
-
-#if !defined(__has_feature)
-#define __has_feature(x) 0
-#endif
-
-#if !defined(__has_attribute)
-#define __has_attribute(x) 0
-#endif
-
-#if !defined(__has_builtin)
-#define __has_builtin(builtin) 0
-#endif
-
-#if !defined(__has_cpp_attribute)
-#define __has_cpp_attribute(attribute) 0
-#endif
-
-#if __has_feature(nullability)
-// Provide macros to temporarily suppress warning about the use of
-// _Nullable and _Nonnull.
-# define SWIFT_BEGIN_NULLABILITY_ANNOTATIONS                        \
-  _Pragma("clang diagnostic push")                                  \
-  _Pragma("clang diagnostic ignored \"-Wnullability-extension\"")
-# define SWIFT_END_NULLABILITY_ANNOTATIONS                          \
-  _Pragma("clang diagnostic pop")
-
-#else
-// #define _Nullable and _Nonnull to nothing if we're not being built
-// with a compiler that supports them.
-# define _Nullable
-# define _Nonnull
-# define SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
-# define SWIFT_END_NULLABILITY_ANNOTATIONS
-#endif
-
-#define SWIFT_MACRO_CONCAT(A, B) A ## B
-#define SWIFT_MACRO_IF_0(IF_TRUE, IF_FALSE) IF_FALSE
-#define SWIFT_MACRO_IF_1(IF_TRUE, IF_FALSE) IF_TRUE
-#define SWIFT_MACRO_IF(COND, IF_TRUE, IF_FALSE) \
-  SWIFT_MACRO_CONCAT(SWIFT_MACRO_IF_, COND)(IF_TRUE, IF_FALSE)
-
-#if __has_attribute(pure)
-#define SWIFT_READONLY __attribute__((__pure__))
-#else
-#define SWIFT_READONLY
-#endif
-
-#if __has_attribute(const)
-#define SWIFT_READNONE __attribute__((__const__))
-#else
-#define SWIFT_READNONE
-#endif
-
-#if __has_attribute(always_inline)
-#define SWIFT_ALWAYS_INLINE __attribute__((always_inline))
-#else
-#define SWIFT_ALWAYS_INLINE
-#endif
-
-#if __has_attribute(noinline)
-#define SWIFT_NOINLINE __attribute__((__noinline__))
-#else
-#define SWIFT_NOINLINE
-#endif
-
-#if __has_attribute(noreturn)
-#define SWIFT_NORETURN __attribute__((__noreturn__))
-#else
-#define SWIFT_NORETURN
-#endif
-
-#if __has_attribute(used)
-#define SWIFT_USED __attribute__((__used__))
-#else
-#define SWIFT_USED
-#endif
-
-#if __has_attribute(unavailable)
-#define SWIFT_ATTRIBUTE_UNAVAILABLE __attribute__((__unavailable__))
-#else
-#define SWIFT_ATTRIBUTE_UNAVAILABLE
-#endif
-
-// Define the appropriate attributes for sharing symbols across
-// image (executable / shared-library) boundaries.
-//
-// SWIFT_ATTRIBUTE_FOR_EXPORTS will be placed on declarations that
-// are known to be exported from the current image.  Typically, they
-// are placed on header declarations and then inherited by the actual
-// definitions.
-//
-// SWIFT_ATTRIBUTE_FOR_IMPORTS will be placed on declarations that
-// are known to be exported from a different image.  This never
-// includes a definition.
-//
-// Getting the right attribute on a declaratioon can be pretty awkward,
-// but it's necessary under the C translation model.  All of this
-// ceremony is familiar to Windows programmers; C/C++ programmers
-// everywhere else usually don't bother, but since we have to get it
-// right for Windows, we have everything set up to get it right on
-// other targets as well, and doing so lets the compiler use more
-// efficient symbol access patterns.
-#if defined(__MACH__) || defined(__wasi__)
-
-// On Mach-O and WebAssembly, we use non-hidden visibility.  We just use
-// default visibility on both imports and exports, both because these
-// targets don't support protected visibility but because they don't
-// need it: symbols are not interposable outside the current image
-// by default.
-# define SWIFT_ATTRIBUTE_FOR_EXPORTS __attribute__((__visibility__("default")))
-# define SWIFT_ATTRIBUTE_FOR_IMPORTS __attribute__((__visibility__("default")))
-
-#elif defined(__ELF__)
-
-// On ELF, we use non-hidden visibility.  For exports, we must use
-// protected visibility to tell the compiler and linker that the symbols
-// can't be interposed outside the current image.  For imports, we must
-// use default visibility because protected visibility guarantees that
-// the symbol is defined in the current library, which isn't true for
-// an import.
-//
-// The compiler does assume that the runtime and standard library can
-// refer to each other's symbols as DSO-local, so it's important that
-// we get this right or we can get linker errors.
-# define SWIFT_ATTRIBUTE_FOR_EXPORTS __attribute__((__visibility__("protected")))
-# define SWIFT_ATTRIBUTE_FOR_IMPORTS __attribute__((__visibility__("default")))
-
-#elif defined(__CYGWIN__)
-
-// For now, we ignore all this on Cygwin.
-# define SWIFT_ATTRIBUTE_FOR_EXPORTS
-# define SWIFT_ATTRIBUTE_FOR_IMPORTS
-
-// FIXME: this #else should be some sort of #elif Windows
-#else // !__MACH__ && !__ELF__
-
-// On PE/COFF, we use dllimport and dllexport.
-# define SWIFT_ATTRIBUTE_FOR_EXPORTS __declspec(dllexport)
-# define SWIFT_ATTRIBUTE_FOR_IMPORTS __declspec(dllimport)
-
-#endif
-
-// CMake conventionally passes -DlibraryName_EXPORTS when building
-// code that goes into libraryName.  This isn't the best macro name,
-// but it's conventional.  We do have to pass it explicitly in a few
-// places in the build system for a variety of reasons.
-//
-// Unfortunately, defined(D) is a special function you can use in
-// preprocessor conditions, not a macro you can use anywhere, so we
-// need to manually check for all the libraries we know about so that
-// we can use them in our condition below.s
-#if defined(swiftCore_EXPORTS)
-#define SWIFT_IMAGE_EXPORTS_swiftCore 1
-#else
-#define SWIFT_IMAGE_EXPORTS_swiftCore 0
-#endif
-#if defined(swift_Concurrency_EXPORTS)
-#define SWIFT_IMAGE_EXPORTS_swift_Concurrency 1
-#else
-#define SWIFT_IMAGE_EXPORTS_swift_Concurrency 0
-#endif
-#if defined(swift_Differentiation_EXPORTS)
-#define SWIFT_IMAGE_EXPORTS_swift_Differentiation 1
-#else
-#define SWIFT_IMAGE_EXPORTS_swift_Differentiation 0
-#endif
-
-#define SWIFT_EXPORT_FROM_ATTRIBUTE(LIBRARY)                          \
-  SWIFT_MACRO_IF(SWIFT_IMAGE_EXPORTS_##LIBRARY,                       \
-                 SWIFT_ATTRIBUTE_FOR_EXPORTS,                         \
-                 SWIFT_ATTRIBUTE_FOR_IMPORTS)
-
-// SWIFT_EXPORT_FROM(LIBRARY) declares something to be a C-linkage
-// entity exported by the given library.
-//
-// SWIFT_RUNTIME_EXPORT is just SWIFT_EXPORT_FROM(swiftCore).
-//
-// TODO: use this in shims headers in overlays.
-#if defined(__cplusplus)
-#define SWIFT_EXPORT_FROM(LIBRARY) extern "C" SWIFT_EXPORT_FROM_ATTRIBUTE(LIBRARY)
-#else
-#define SWIFT_EXPORT_FROM(LIBRARY) SWIFT_EXPORT_FROM_ATTRIBUTE(LIBRARY)
-#endif
-#define SWIFT_RUNTIME_EXPORT SWIFT_EXPORT_FROM(swiftCore)
-
-#if __cplusplus > 201402l && __has_cpp_attribute(fallthrough)
-#define SWIFT_FALLTHROUGH [[fallthrough]]
-#elif __has_cpp_attribute(gnu::fallthrough)
-#define SWIFT_FALLTHROUGH [[gnu::fallthrough]]
-#elif __has_cpp_attribute(clang::fallthrough)
-#define SWIFT_FALLTHROUGH [[clang::fallthrough]]
-#elif __has_attribute(fallthrough)
-#define SWIFT_FALLTHROUGH __attribute__((__fallthrough__))
-#else
-#define SWIFT_FALLTHROUGH
-#endif
-
-#if __cplusplus >= 201402l && __has_cpp_attribute(nodiscard)
-#define SWIFT_NODISCARD [[nodiscard]]
-#elif __has_cpp_attribute(clang::warn_unused_result)
-#define SWIFT_NODISCARD [[clang::warn_unused_result]]
-#else
-#define SWIFT_NODISCARD
-#endif
-
-
-/// Attributes for runtime-stdlib interfaces.
-/// Use these for C implementations that are imported into Swift via SwiftShims
-/// and for C implementations of Swift @_silgen_name declarations
-/// Note that @_silgen_name implementations must also be marked SWIFT_CC(swift).
-///
-/// SWIFT_RUNTIME_STDLIB_API functions are called by compiler-generated code
-/// or by @inlinable Swift code.
-/// Such functions must be exported and must be supported forever as API.
-/// The function name should be prefixed with `swift_`.
-///
-/// SWIFT_RUNTIME_STDLIB_SPI functions are called by overlay code.
-/// Such functions must be exported, but are still SPI
-/// and may be changed at any time.
-/// The function name should be prefixed with `_swift_`.
-///
-/// SWIFT_RUNTIME_STDLIB_INTERNAL functions are called only by the stdlib.
-/// Such functions are internal and are not exported.
-#define SWIFT_RUNTIME_STDLIB_API       SWIFT_RUNTIME_EXPORT
-#define SWIFT_RUNTIME_STDLIB_SPI       SWIFT_RUNTIME_EXPORT
-
-// Match the definition of LLVM_LIBRARY_VISIBILITY from LLVM's
-// Compiler.h. That header requires C++ and this needs to work in C.
-#if __has_attribute(visibility) && (defined(__ELF__) || defined(__MACH__))
-#define SWIFT_LIBRARY_VISIBILITY __attribute__ ((__visibility__("hidden")))
-#else
-#define SWIFT_LIBRARY_VISIBILITY
-#endif
-
-#if defined(__cplusplus)
-#define SWIFT_RUNTIME_STDLIB_INTERNAL extern "C" SWIFT_LIBRARY_VISIBILITY
-#else
-#define SWIFT_RUNTIME_STDLIB_INTERNAL SWIFT_LIBRARY_VISIBILITY
-#endif
-
-#if __has_builtin(__builtin_expect)
-#define SWIFT_LIKELY(expression) (__builtin_expect(!!(expression), 1))
-#define SWIFT_UNLIKELY(expression) (__builtin_expect(!!(expression), 0))
-#else
-#define SWIFT_LIKELY(expression) ((expression))
-#define SWIFT_UNLIKELY(expression) ((expression))
-#endif
-
-// SWIFT_STDLIB_SHIMS_VISIBILITY_H
-#endif
diff --git a/symbolic-demangle/vendor/swift/update.py b/symbolic-demangle/vendor/swift/update.py
index 9623ba852..68a9f84ac 100755
--- a/symbolic-demangle/vendor/swift/update.py
+++ b/symbolic-demangle/vendor/swift/update.py
@@ -10,6 +10,7 @@
 DEMANGLING_PATH = "lib/Demangling"
 WORKSPACE_INCLUDES = [
     'llvm-project/llvm/include',
+    'llbuild/include',
     'build/Ninja-DebugAssert/llvm-macosx-x86_64/include',
     'build/Ninja-DebugAssert/swift-macosx-x86_64/include',
     'swift/include',
diff --git a/symbolic-il2cpp/Cargo.toml b/symbolic-il2cpp/Cargo.toml
index 0d1e94d94..7206bba76 100644
--- a/symbolic-il2cpp/Cargo.toml
+++ b/symbolic-il2cpp/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-il2cpp"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 authors = ["Sentry <hello@sentry.io>"]
 documentation = "https://docs.rs/symbolic-il2cpp"
@@ -9,10 +9,11 @@ repository = "https://github.com/getsentry/symbolic"
 description = """
 A library for parsing il2cpp line mappings.
 """
-edition = "2021"
+edition.workspace = true
+rust-version.workspace = true
 
 [dependencies]
 indexmap = { workspace = true }
 serde_json = { workspace = true }
-symbolic-common = { version = "12.9.2-dd", path = "../symbolic-common" }
-symbolic-debuginfo = { version = "12.9.2-dd", path = "../symbolic-debuginfo" }
+symbolic-common = { version = "12.17.0-dd", path = "../symbolic-common" }
+symbolic-debuginfo = { version = "12.17.0-dd", path = "../symbolic-debuginfo" }
diff --git a/symbolic-ppdb/Cargo.toml b/symbolic-ppdb/Cargo.toml
index 05e012e4b..5180501f8 100644
--- a/symbolic-ppdb/Cargo.toml
+++ b/symbolic-ppdb/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-ppdb"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 authors = [
     "Sebastian Zivota <sebastian.zivota@sentry.io>",
@@ -12,7 +12,8 @@ repository = "https://github.com/getsentry/symbolic"
 description = """
 A library for parsing and performing lookups on Portable PDB files.
 """
-edition = "2021"
+edition.workspace = true
+rust-version.workspace = true
 
 exclude = ["tests/**/*"]
 
@@ -24,7 +25,7 @@ flate2 = { workspace = true }
 indexmap = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-symbolic-common = { version = "12.9.2-dd", path = "../symbolic-common" }
+symbolic-common = { version = "12.17.0-dd", path = "../symbolic-common" }
 thiserror = { workspace = true }
 uuid = { workspace = true }
 watto = { workspace = true }
diff --git a/symbolic-ppdb/fuzz/Cargo.toml b/symbolic-ppdb/fuzz/Cargo.toml
index 72d959cae..2369153ef 100644
--- a/symbolic-ppdb/fuzz/Cargo.toml
+++ b/symbolic-ppdb/fuzz/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-ppdb-fuzz"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 authors = ["Automatically generated"]
 publish = false
 edition = "2021"
diff --git a/symbolic-ppdb/src/cache/mod.rs b/symbolic-ppdb/src/cache/mod.rs
index 6330e9dad..f387e9afa 100644
--- a/symbolic-ppdb/src/cache/mod.rs
+++ b/symbolic-ppdb/src/cache/mod.rs
@@ -207,7 +207,7 @@ impl<'data> PortablePdbCache<'data> {
     }
 }
 
-impl<'data> std::fmt::Debug for PortablePdbCache<'data> {
+impl std::fmt::Debug for PortablePdbCache<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("PortablePdbCache")
             .field("version", &self.header.version)
@@ -222,7 +222,7 @@ impl<'data> std::fmt::Debug for PortablePdbCache<'data> {
 impl<'slf, 'd: 'slf> AsSelf<'slf> for PortablePdbCache<'d> {
     type Ref = PortablePdbCache<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
diff --git a/symbolic-ppdb/src/format/metadata.rs b/symbolic-ppdb/src/format/metadata.rs
index ee11a7da5..95ec9a309 100644
--- a/symbolic-ppdb/src/format/metadata.rs
+++ b/symbolic-ppdb/src/format/metadata.rs
@@ -128,7 +128,7 @@ pub struct Table<'data> {
     contents: &'data [u8],
 }
 
-impl<'data> fmt::Debug for Table<'data> {
+impl fmt::Debug for Table<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let cols: Vec<usize> = self
             .columns
@@ -216,7 +216,7 @@ impl<'data> Table<'data> {
     /// Returns the the bytes of the `idx`th row, if any.
     ///
     /// Note that table row indices are 1-based!
-    pub(crate) fn get_row(&self, idx: usize) -> Result<Row, FormatError> {
+    pub(crate) fn get_row(&self, idx: usize) -> Result<Row<'_>, FormatError> {
         idx.checked_sub(1)
             .and_then(|idx| self.contents.get(idx * self.width..(idx + 1) * self.width))
             .map(|data| Row { data, table: self })
@@ -231,7 +231,7 @@ pub(crate) struct Row<'data> {
     table: &'data Table<'data>,
 }
 
-impl<'data> Row<'data> {
+impl Row<'_> {
     /// Reads the `col` cell in the given table as a `u32`.
     ///
     /// This returns an error if the indices are out of bounds for the table
@@ -354,7 +354,7 @@ impl<'data> MetadataStream<'data> {
             contents: <&[u8]>::default(),
         }; 64];
         for (i, table) in tables.iter_mut().enumerate() {
-            if (header.valid_tables >> i & 1) == 0 {
+            if ((header.valid_tables >> i) & 1) == 0 {
                 continue;
             }
 
@@ -861,7 +861,7 @@ impl<'data> Index<TableType> for MetadataStream<'data> {
     }
 }
 
-impl<'data> IndexMut<TableType> for MetadataStream<'data> {
+impl IndexMut<TableType> for MetadataStream<'_> {
     fn index_mut(&mut self, index: TableType) -> &mut Self::Output {
         &mut self.tables[index as usize]
     }
@@ -910,7 +910,7 @@ macro_rules! ok_or_return {
     };
 }
 
-impl<'data> Iterator for CustomDebugInformationIterator<'data> {
+impl Iterator for CustomDebugInformationIterator<'_> {
     type Item = Result<CustomDebugInformation, FormatError>;
 
     fn next(&mut self) -> Option<Self::Item> {
diff --git a/symbolic-ppdb/src/format/mod.rs b/symbolic-ppdb/src/format/mod.rs
index 3f9e2dd85..d54508885 100644
--- a/symbolic-ppdb/src/format/mod.rs
+++ b/symbolic-ppdb/src/format/mod.rs
@@ -352,7 +352,7 @@ impl<'data> PortablePdb<'data> {
     /// or the cell is too wide for a `u32`.
     ///
     /// Note that row and column indices are 1-based!
-    pub(crate) fn get_table(&self, table: TableType) -> Result<Table, FormatError> {
+    pub(crate) fn get_table(&self, table: TableType) -> Result<Table<'_>, FormatError> {
         let md_stream = self
             .metadata_stream
             .as_ref()
@@ -362,9 +362,9 @@ impl<'data> PortablePdb<'data> {
 
     /// Returns true if this portable pdb file contains method debug information.
     pub fn has_debug_info(&self) -> bool {
-        self.metadata_stream.as_ref().map_or(false, |md_stream| {
-            md_stream[TableType::MethodDebugInformation].rows > 0
-        })
+        self.metadata_stream
+            .as_ref()
+            .is_some_and(|md_stream| md_stream[TableType::MethodDebugInformation].rows > 0)
     }
 
     /// Get source file referenced by this PDB.
@@ -442,7 +442,7 @@ impl<'object, 'data> EmbeddedSourceIterator<'object, 'data> {
     }
 }
 
-impl<'object, 'data> Iterator for EmbeddedSourceIterator<'object, 'data> {
+impl<'data> Iterator for EmbeddedSourceIterator<'_, 'data> {
     type Item = Result<EmbeddedSource<'data>, FormatError>;
 
     fn next(&mut self) -> Option<Self::Item> {
diff --git a/symbolic-ppdb/src/format/sequence_points.rs b/symbolic-ppdb/src/format/sequence_points.rs
index 476dad4e3..dd8e46088 100644
--- a/symbolic-ppdb/src/format/sequence_points.rs
+++ b/symbolic-ppdb/src/format/sequence_points.rs
@@ -266,7 +266,7 @@ pub(crate) struct SequencePoints<'data, 'ppdb> {
     count: usize,
 }
 
-impl<'data, 'ppdb> Iterator for SequencePoints<'data, 'ppdb> {
+impl Iterator for SequencePoints<'_, '_> {
     type Item = Result<Vec<SequencePoint>, FormatError>;
 
     fn next(&mut self) -> Option<Self::Item> {
diff --git a/symbolic-ppdb/src/format/streams.rs b/symbolic-ppdb/src/format/streams.rs
index 67b767c79..0ad92f167 100644
--- a/symbolic-ppdb/src/format/streams.rs
+++ b/symbolic-ppdb/src/format/streams.rs
@@ -48,7 +48,7 @@ impl<'data> PdbStream<'data> {
 
         let mut referenced_table_sizes = [0; 64];
         for (i, table) in referenced_table_sizes.iter_mut().enumerate() {
-            if (header.referenced_tables >> i & 1) == 0 {
+            if ((header.referenced_tables >> i) & 1) == 0 {
                 continue;
             }
 
diff --git a/symbolic-sourcemapcache/Cargo.toml b/symbolic-sourcemapcache/Cargo.toml
index 7c93714a8..970a79d65 100644
--- a/symbolic-sourcemapcache/Cargo.toml
+++ b/symbolic-sourcemapcache/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-sourcemapcache"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 authors = ["Sentry <hello@sentry.io>"]
 documentation = "https://docs.rs/symbolic-sourcemapcache"
@@ -15,7 +15,7 @@ edition = "2021"
 itertools = { workspace = true }
 js-source-scopes = { workspace = true }
 sourcemap = { workspace = true }
-symbolic-common = { version = "12.9.2-dd", path = "../symbolic-common" }
+symbolic-common = { version = "12.17.0-dd", path = "../symbolic-common" }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 watto = { workspace = true }
diff --git a/symbolic-sourcemapcache/src/lookup.rs b/symbolic-sourcemapcache/src/lookup.rs
index 2f5c6d8d7..bfba5c686 100644
--- a/symbolic-sourcemapcache/src/lookup.rs
+++ b/symbolic-sourcemapcache/src/lookup.rs
@@ -82,12 +82,12 @@ pub struct SourceMapCache<'data> {
 impl<'slf, 'a: 'slf> AsSelf<'slf> for SourceMapCache<'a> {
     type Ref = SourceMapCache<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
 
-impl<'data> std::fmt::Debug for SourceMapCache<'data> {
+impl std::fmt::Debug for SourceMapCache<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("SourceMapCache")
             .field("version", &self.header.version)
@@ -170,15 +170,27 @@ impl<'data> SourceMapCache<'data> {
     /// Looks up a [`SourcePosition`] in the minified source and resolves it
     /// to the original [`SourceLocation`].
     #[tracing::instrument(level = "trace", name = "SourceMapCache::lookup", skip_all)]
-    pub fn lookup(&self, sp: SourcePosition) -> Option<SourceLocation> {
+    pub fn lookup(&self, sp: SourcePosition) -> Option<SourceLocation<'_>> {
         let idx = match self.min_source_positions.binary_search(&sp.into()) {
             Ok(idx) => idx,
-            Err(0) => 0,
+            Err(0) => return None,
             Err(idx) => idx - 1,
         };
 
+        // If the token has a lower minified line number,
+        // it actually belongs to the previous line. That means it should
+        // not match.
+        if self.min_source_positions.get(idx)?.line < sp.line {
+            return None;
+        }
+
         let sl = self.orig_source_locations.get(idx)?;
 
+        // If file, line, and column are all absent (== `u32::MAX`), this location is simply unmapped.
+        if sl.file_idx == raw::NO_FILE_SENTINEL && sl.line == u32::MAX && sl.column == u32::MAX {
+            return None;
+        }
+
         let line = sl.line;
         let column = sl.column;
 
@@ -376,4 +388,43 @@ mod tests {
         assert_eq!(file.line(3), Some("c\n"));
         assert_eq!(file.line(4), Some(""));
     }
+
+    #[test]
+    fn unmapped_token() {
+        let minified = r#""foo"; /*added by bundler*/ "bar";"#;
+        let sourcemap = r#"{"version":3,"file":"test.min.js","sources":["test.js"],"sourcesContent":["\"foo\":\n\"baz\";"],"names":[],"mappings":"AAAA,M,sBACA"}"#;
+
+        let mut buf = vec![];
+        SourceMapCacheWriter::new(minified, sourcemap)
+            .unwrap()
+            .serialize(&mut buf)
+            .unwrap();
+
+        let cache = SourceMapCache::parse(&buf).unwrap();
+
+        // "foo";
+        let foo = cache.lookup(SourcePosition { line: 0, column: 4 }).unwrap();
+        assert_eq!(foo.file_name().unwrap(), "test.js");
+        assert_eq!(foo.line, 0);
+        assert_eq!(foo.column, 0);
+
+        // comment
+        // this should be unmapped
+        assert!(dbg!(cache.lookup(SourcePosition {
+            line: 0,
+            column: 17
+        }))
+        .is_none());
+
+        // "bar";
+        let bar = cache
+            .lookup(SourcePosition {
+                line: 0,
+                column: 30,
+            })
+            .unwrap();
+        assert_eq!(bar.file_name().unwrap(), "test.js");
+        assert_eq!(bar.line, 1);
+        assert_eq!(bar.column, 0);
+    }
 }
diff --git a/symbolic-sourcemapcache/tests/integration.rs b/symbolic-sourcemapcache/tests/integration.rs
index 0b1439cf1..9f53cea1b 100644
--- a/symbolic-sourcemapcache/tests/integration.rs
+++ b/symbolic-sourcemapcache/tests/integration.rs
@@ -38,6 +38,9 @@ fn resolves_inlined_function() {
     assert_eq!(sl.line(), 1);
     assert_eq!(sl.column(), 8);
     assert_eq!(sl.scope(), ScopeLookupResult::AnonymousScope);
+
+    // There are no mappings for line 1 in the sourcemap.
+    assert!(cache.lookup(SourcePosition::new(1, 17)).is_none());
 }
 
 #[test]
diff --git a/symbolic-symcache/Cargo.toml b/symbolic-symcache/Cargo.toml
index 61582da2c..179e7886a 100644
--- a/symbolic-symcache/Cargo.toml
+++ b/symbolic-symcache/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-symcache"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 authors = [
     "Armin Ronacher <armin.ronacher@active-4.com>",
@@ -13,7 +13,8 @@ description = """
 An optimized cache file for fast and memory efficient lookup of symbols and
 stack frames in debugging information.
 """
-edition = "2021"
+edition.workspace = true
+rust-version.workspace = true
 
 exclude = ["tests/**/*"]
 
@@ -22,9 +23,9 @@ all-features = true
 
 [dependencies]
 indexmap = { workspace = true }
-symbolic-common = { version = "12.9.2-dd", path = "../symbolic-common" }
-symbolic-debuginfo = { version = "12.9.2-dd", path = "../symbolic-debuginfo" }
-symbolic-il2cpp = { version = "12.9.2-dd", path = "../symbolic-il2cpp", optional = true }
+symbolic-common = { version = "12.17.0-dd", path = "../symbolic-common" }
+symbolic-debuginfo = { version = "12.17.0-dd", path = "../symbolic-debuginfo" }
+symbolic-il2cpp = { version = "12.17.0-dd", path = "../symbolic-il2cpp", optional = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 watto = { workspace = true }
diff --git a/symbolic-symcache/src/lib.rs b/symbolic-symcache/src/lib.rs
index 670f03d21..d0d9f7b1d 100644
--- a/symbolic-symcache/src/lib.rs
+++ b/symbolic-symcache/src/lib.rs
@@ -147,7 +147,7 @@ pub struct SymCache<'data> {
     string_bytes: &'data [u8],
 }
 
-impl<'data> std::fmt::Debug for SymCache<'data> {
+impl std::fmt::Debug for SymCache<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("SymCache")
             .field("version", &self.header.version)
@@ -268,7 +268,7 @@ impl<'data> SymCache<'data> {
 impl<'slf, 'd: 'slf> AsSelf<'slf> for SymCache<'d> {
     type Ref = SymCache<'slf>;
 
-    fn as_self(&'slf self) -> &Self::Ref {
+    fn as_self(&'slf self) -> &'slf Self::Ref {
         self
     }
 }
diff --git a/symbolic-symcache/src/lookup.rs b/symbolic-symcache/src/lookup.rs
index e7635d750..ec72dbfaa 100644
--- a/symbolic-symcache/src/lookup.rs
+++ b/symbolic-symcache/src/lookup.rs
@@ -91,7 +91,7 @@ pub struct File<'data> {
     name: &'data str,
 }
 
-impl<'data> File<'data> {
+impl File<'_> {
     /// Returns this file's full path.
     pub fn full_path(&self) -> String {
         let comp_dir = self.comp_dir.unwrap_or_default();
@@ -135,7 +135,7 @@ impl<'data> Function<'data> {
     }
 }
 
-impl<'data> Default for Function<'data> {
+impl Default for Function<'_> {
     fn default() -> Self {
         Self {
             name: "?",
@@ -155,7 +155,7 @@ pub struct SourceLocation<'data, 'cache> {
     pub(crate) source_location: &'data raw::SourceLocation,
 }
 
-impl<'data, 'cache> SourceLocation<'data, 'cache> {
+impl<'data> SourceLocation<'data, '_> {
     /// The source line corresponding to the instruction.
     ///
     /// 0 denotes an unknown line number.
@@ -228,10 +228,11 @@ impl<'data> Iterator for Functions<'data> {
             }
         }
 
-        function.map(|f| {
+        if function.is_some() {
             self.function_idx += 1;
-            f
-        })
+        }
+
+        function
     }
 }
 
@@ -266,10 +267,11 @@ impl<'data> Iterator for Files<'data> {
     type Item = File<'data>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.cache.get_file(self.file_idx).map(|f| {
+        let file = self.cache.get_file(self.file_idx);
+        if file.is_some() {
             self.file_idx += 1;
-            f
-        })
+        }
+        file
     }
 }
 
diff --git a/symbolic-symcache/src/transform/mod.rs b/symbolic-symcache/src/transform/mod.rs
index 1dda26090..453a87ec5 100644
--- a/symbolic-symcache/src/transform/mod.rs
+++ b/symbolic-symcache/src/transform/mod.rs
@@ -58,7 +58,7 @@ pub trait Transformer {
 #[derive(Default)]
 pub(crate) struct Transformers<'a>(pub Vec<Box<dyn Transformer + 'a>>);
 
-impl<'a> std::fmt::Debug for Transformers<'a> {
+impl std::fmt::Debug for Transformers<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let len = self.0.len();
         f.debug_tuple("Transformers").field(&len).finish()
diff --git a/symbolic-symcache/src/writer.rs b/symbolic-symcache/src/writer.rs
index 7b0775b7d..728f95e1e 100644
--- a/symbolic-symcache/src/writer.rs
+++ b/symbolic-symcache/src/writer.rs
@@ -10,6 +10,7 @@ use symbolic_debuginfo::{DebugSession, FileFormat, Function, ObjectLike, Symbol}
 use watto::{Pod, StringTable, Writer};
 
 use super::{raw, transform};
+use crate::raw::NO_SOURCE_LOCATION;
 use crate::{Error, ErrorKind};
 
 /// The SymCache Converter.
@@ -188,8 +189,7 @@ impl<'a> SymCacheConverter<'a> {
         let mut inlinee_ranges = Vec::new();
         for inlinee in &function.inlinees {
             for line in &inlinee.lines {
-                let start = line.address as u32;
-                let end = (line.address + line.size.unwrap_or(1)) as u32;
+                let (start, end) = line_boundaries(line.address, line.size);
                 inlinee_ranges.push(start..end);
             }
         }
@@ -213,8 +213,7 @@ impl<'a> SymCacheConverter<'a> {
 
         // Iterate over the line records.
         while let Some(line) = next_line.take() {
-            let line_range_start = line.address as u32;
-            let line_range_end = (line.address + line.size.unwrap_or(1)) as u32;
+            let (line_range_start, line_range_end) = line_boundaries(line.address, line.size);
 
             // Find the call location for this line.
             while next_call_location.is_some() && next_call_location.unwrap().0 <= line_range_start
@@ -308,16 +307,19 @@ impl<'a> SymCacheConverter<'a> {
             let mut current_address = line_range_start;
             while current_address < line_range_end {
                 // Emit our source location at current_address if current_address is not covered by an inlinee.
-                if next_inline.is_none() || next_inline.as_ref().unwrap().start > current_address {
+                if next_inline
+                    .as_ref()
+                    .is_none_or(|next| next.start > current_address)
+                {
                     // "insert_range"
                     self.ranges.insert(current_address, source_location.clone());
                 }
 
                 // If there is an inlinee range covered by this line record, turn this line into that
                 // call's "call line". Make a `call_location_idx` for it and store it in `callee_call_locations`.
-                if next_inline.is_some() && next_inline.as_ref().unwrap().start < line_range_end {
-                    let inline_range = next_inline.take().unwrap();
-
+                if let Some(inline_range) =
+                    take_if(&mut next_inline, |next| next.start < line_range_end)
+                {
                     // "make_call_location"
                     let (call_location_idx, _) =
                         self.call_locations.insert_full(source_location.clone());
@@ -341,8 +343,9 @@ impl<'a> SymCacheConverter<'a> {
             // multiple identical small "call line" records instead of one combined record
             // covering the entire inlinee range. We can't have different "call lines" for a single
             // inlinee range anyway, so it's fine to skip these.
-            while next_line.is_some()
-                && (next_line.as_ref().unwrap().address as u32) < current_address
+            while next_line
+                .as_ref()
+                .is_some_and(|next| (next.address as u32) < current_address)
             {
                 next_line = line_iter.next();
             }
@@ -350,7 +353,7 @@ impl<'a> SymCacheConverter<'a> {
 
         if !function.inline {
             // add the bare minimum of information for the function if there isn't any.
-            self.ranges.entry(entry_pc).or_insert(raw::SourceLocation {
+            insert_source_location(&mut self.ranges, entry_pc, || raw::SourceLocation {
                 file_idx: u32::MAX,
                 line: 0,
                 function_idx,
@@ -372,6 +375,19 @@ impl<'a> SymCacheConverter<'a> {
         if function_end > *last_addr {
             *last_addr = function_end;
         }
+
+        // Insert an explicit "empty" mapping for the end of the function.
+        // This is to ensure that addresses that fall "between" functions don't get
+        // erroneously mapped to the previous function.
+        //
+        // We only do this if there is no previous mapping for the end address—we don't
+        // want to overwrite valid mappings.
+        //
+        // If the next function starts right at this function's end, that's no trouble,
+        // it will just overwrite this mapping with one of its ranges.
+        if let btree_map::Entry::Vacant(vacant_entry) = self.ranges.entry(function_end) {
+            vacant_entry.insert(NO_SOURCE_LOCATION);
+        }
     }
 
     /// Processes an individual [`Symbol`].
@@ -397,37 +413,45 @@ impl<'a> SymCacheConverter<'a> {
             self.string_table.insert(function_name) as u32
         };
 
-        match self.ranges.entry(symbol.address as u32) {
-            btree_map::Entry::Vacant(entry) => {
-                let function = raw::Function {
-                    name_offset: name_idx,
-                    _comp_dir_offset: u32::MAX,
-                    entry_pc: symbol.address as u32,
-                    lang: u32::MAX,
-                };
-                let function_idx = self.functions.insert_full(function).0 as u32;
-
-                entry.insert(raw::SourceLocation {
-                    file_idx: u32::MAX,
-                    line: 0,
-                    function_idx,
-                    inlined_into_idx: u32::MAX,
-                });
-            }
-            btree_map::Entry::Occupied(entry) => {
-                // ASSUMPTION:
-                // the `functions` iterator has already filled in this addr via debug session.
-                // we could trace the caller hierarchy up to the root, and assert that it is
-                // indeed the same function, and maybe update its `entry_pc`, but we don’t do
-                // that for now.
-                let _function_idx = entry.get().function_idx as usize;
+        // Insert a source location for the symbol, overwriting `NO_SOURCE_LOCATION` sentinel
+        // values but not actual source locations coming from e.g. functions.
+        insert_source_location(&mut self.ranges, symbol.address as u32, || {
+            let function = raw::Function {
+                name_offset: name_idx,
+                _comp_dir_offset: u32::MAX,
+                entry_pc: symbol.address as u32,
+                lang: u32::MAX,
+            };
+            let function_idx = self.functions.insert_full(function).0 as u32;
+
+            raw::SourceLocation {
+                file_idx: u32::MAX,
+                line: 0,
+                function_idx,
+                inlined_into_idx: u32::MAX,
             }
-        }
+        });
 
         let last_addr = self.last_addr.get_or_insert(0);
         if symbol.address as u32 >= *last_addr {
             self.last_addr = None;
         }
+
+        // Insert an explicit "empty" mapping for the end of the symbol.
+        // This is to ensure that addresses that fall "between" symbols don't get
+        // erroneously mapped to the previous symbol.
+        //
+        // We only do this if there is no previous mapping for the end address—we don't
+        // want to overwrite valid mappings.
+        //
+        // If the next symbol starts right at this symbols's end, that's no trouble,
+        // it will just overwrite this mapping.
+        if symbol.size > 0 {
+            let end_address = (symbol.address + symbol.size) as u32;
+            if let btree_map::Entry::Vacant(vacant_entry) = self.ranges.entry(end_address) {
+                vacant_entry.insert(NO_SOURCE_LOCATION);
+            }
+        }
     }
 
     // Methods for serializing to a [`Write`] below:
@@ -507,6 +531,29 @@ impl<'a> SymCacheConverter<'a> {
     }
 }
 
+/// Inserts a source location into a map, but only if there either isn't already
+/// a value for the provided key or the value is the `NO_SOURCE_LOCATION` sentinel.
+///
+/// This is useful because a `NO_SOURCE_LOCATION` value may be inserted at an address to explicitly
+/// mark the end of a function or symbol. If later there is a function, symbol, or range
+/// starting at that same address, we want to evict that sentinel, but we wouldn't want to
+/// evict source locations carrying actual information.
+fn insert_source_location<K, F>(
+    source_locations: &mut BTreeMap<K, raw::SourceLocation>,
+    key: K,
+    val: F,
+) where
+    K: Ord,
+    F: FnOnce() -> raw::SourceLocation,
+{
+    if source_locations
+        .get(&key)
+        .is_none_or(|sl| *sl == NO_SOURCE_LOCATION)
+    {
+        source_locations.insert(key, val());
+    }
+}
+
 /// Undecorates a Windows C-decorated symbol name.
 ///
 /// The decoration rules are explained here:
@@ -550,3 +597,48 @@ fn undecorate_win_symbol(name: &str) -> &str {
 
     name
 }
+
+/// Returns the start and end address for a line record, clamped to `u32`.
+fn line_boundaries(address: u64, size: Option<u64>) -> (u32, u32) {
+    let start = address.try_into().unwrap_or(u32::MAX);
+    let end = start.saturating_add(size.unwrap_or(1).try_into().unwrap_or(u32::MAX));
+    (start, end)
+}
+
+fn take_if<T>(opt: &mut Option<T>, predicate: impl FnOnce(&mut T) -> bool) -> Option<T> {
+    if opt.as_mut().is_some_and(predicate) {
+        opt.take()
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Tests that computing a range with a large size naively
+    /// results in an empty range, but using `line_boundaries`
+    /// doesn't.
+    #[test]
+    fn test_large_range() {
+        // Line record values from an actual example
+        let address = 0x11d255;
+        let size = 0xffee9d55;
+
+        let naive_range = {
+            let start = address as u32;
+            let end = (address + size) as u32;
+            start..end
+        };
+
+        assert!(naive_range.is_empty());
+
+        let range = {
+            let (start, end) = line_boundaries(address, Some(size));
+            start..end
+        };
+
+        assert!(!range.is_empty());
+    }
+}
diff --git a/symbolic-symcache/tests/breakpad.rs b/symbolic-symcache/tests/breakpad.rs
index 7e30301a0..a12693c36 100644
--- a/symbolic-symcache/tests/breakpad.rs
+++ b/symbolic-symcache/tests/breakpad.rs
@@ -126,3 +126,21 @@ PUBLIC d80 0 public_record"#;
     let lookup_result: Vec<_> = symcache.lookup(0xfffffa0).collect();
     assert_eq!(lookup_result[0].function().name(), "public_record");
 }
+
+/// Tests the fix for https://github.com/getsentry/symbolic/pull/930.
+#[test]
+fn test_func_no_lines() {
+    let buffer = br#"MODULE mac x86_64 67E9247C814E392BA027DBDE6748FCBF0 crash
+FUNC b2c 10 0 first()
+FUNC b3c 10 0 second()"#;
+    let breakpad = BreakpadObject::parse(buffer).unwrap();
+
+    let mut buffer = Vec::new();
+    let mut converter = SymCacheConverter::new();
+    converter.process_object(&breakpad).unwrap();
+    converter.serialize(&mut Cursor::new(&mut buffer)).unwrap();
+    let symcache = SymCache::parse(&buffer).unwrap();
+
+    let lookup_result: Vec<_> = symcache.lookup(0xb40).collect();
+    assert_eq!(lookup_result[0].function().name(), "second()");
+}
diff --git a/symbolic-symcache/tests/snapshots/test_cache__functions_linux.snap b/symbolic-symcache/tests/snapshots/test_cache__functions_linux.snap
index 48c4cb215..6d1a699c7 100644
--- a/symbolic-symcache/tests/snapshots/test_cache__functions_linux.snap
+++ b/symbolic-symcache/tests/snapshots/test_cache__functions_linux.snap
@@ -1,7 +1,6 @@
 ---
 source: symbolic-symcache/tests/test_cache.rs
 expression: FunctionsDebug(&symcache)
-
 ---
             1558 _init
             1900 _ZN15google_breakpad13PageAllocator7FreeAllEv.isra.6
@@ -170,4 +169,3 @@ expression: FunctionsDebug(&symcache)
            14c30 __libc_csu_init
            14ca0 __libc_csu_fini
            14ca4 _fini
-
diff --git a/symbolic-symcache/tests/snapshots/test_cache__functions_macos.snap b/symbolic-symcache/tests/snapshots/test_cache__functions_macos.snap
index b215b8ccb..b094e4a09 100644
--- a/symbolic-symcache/tests/snapshots/test_cache__functions_macos.snap
+++ b/symbolic-symcache/tests/snapshots/test_cache__functions_macos.snap
@@ -1,7 +1,6 @@
 ---
 source: symbolic-symcache/tests/test_cache.rs
 expression: FunctionsDebug(&symcache)
-
 ---
                0 _mh_execute_header
              d20 _ZN15google_breakpad18MinidumpFileWriterC2Ev
@@ -198,4 +197,3 @@ expression: FunctionsDebug(&symcache)
             db50 _ZN15google_breakpad14MachPortSender11SendMessageERNS_15MachSendMessageEj
             dba0 main
             dc70 _ZN12_GLOBAL__N_18callbackEPKcS1_Pvb
-
diff --git a/symbolic-symcache/tests/snapshots/test_cache__lookup.snap b/symbolic-symcache/tests/snapshots/test_cache__lookup.snap
index 8c7f5d7e0..e9a6d2f88 100644
--- a/symbolic-symcache/tests/snapshots/test_cache__lookup.snap
+++ b/symbolic-symcache/tests/snapshots/test_cache__lookup.snap
@@ -1,7 +1,6 @@
 ---
 source: symbolic-symcache/tests/test_cache.rs
 expression: result
-
 ---
 [
     (
diff --git a/symbolic-symcache/tests/snapshots/test_writer__functions_linux.snap b/symbolic-symcache/tests/snapshots/test_writer__functions_linux.snap
index 3c7b4cbc8..610322bfd 100644
--- a/symbolic-symcache/tests/snapshots/test_writer__functions_linux.snap
+++ b/symbolic-symcache/tests/snapshots/test_writer__functions_linux.snap
@@ -1,7 +1,6 @@
 ---
 source: symbolic-symcache/tests/test_writer.rs
 expression: FunctionsDebug(&symcache)
-
 ---
             1558 _init
             1900 _ZN15google_breakpad13PageAllocator7FreeAllEv.isra.6
@@ -41,7 +40,7 @@ expression: FunctionsDebug(&symcache)
             3670 _ZN15google_breakpad16ExceptionHandlerC1ERKNS_18MinidumpDescriptorEPFbPvEPFbS3_S4_bES4_bi
             3a10 _ZN15google_breakpad16ExceptionHandler13WriteMinidumpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPFbRKNS_18MinidumpDescriptorEPvbESC_
             3cb0 _ZNSt6vectorIPN15google_breakpad16ExceptionHandlerESaIS2_EE19_M_emplace_back_auxIIS2_EEEvDpOT_
-            3da0 _ZN15google_breakpad18MinidumpDescriptorC1ERKS0_
+            3da0 _ZN15google_breakpad18MinidumpDescriptorC2ERKS0_
             3f20 _ZN15google_breakpad18MinidumpDescriptor10UpdatePathEv
             42f0 _ZN15google_breakpad18MinidumpDescriptoraSERKS0_
             43c0 _ZN6logger5writeEPKcm
@@ -49,7 +48,7 @@ expression: FunctionsDebug(&symcache)
             6e10 _ZNSt6vectorIhN15google_breakpad16PageStdAllocatorIhEEE15_M_range_insertIPKhEEvN9__gnu_cxx17__normal_iteratorIPhS3_EET_SB_St20forward_iterator_tag
             71f0 _ZN15google_breakpad11LinuxDumper8LateInitEv
             7200 _ZN15google_breakpad11LinuxDumper17EnumerateMappingsEv
-            7ac0 _ZN15google_breakpad11LinuxDumperC1EiPKc
+            7ac0 _ZN15google_breakpad11LinuxDumperC2EiPKc
             8300 _ZN15google_breakpad11LinuxDumperD2Ev
             8370 _ZN15google_breakpad11LinuxDumperD0Ev
             8390 _ZNK15google_breakpad11LinuxDumper20GetCrashSignalStringEv
@@ -70,14 +69,14 @@ expression: FunctionsDebug(&symcache)
             94a0 _ZNK15google_breakpad17LinuxPtraceDumper12IsPostMortemEv
             94b0 _ZN15google_breakpad17LinuxPtraceDumper15CopyFromProcessEPviPKvm
             9640 _ZN15google_breakpad17LinuxPtraceDumper13ThreadsResumeEv
-            9700 _ZNK15google_breakpad17LinuxPtraceDumper13BuildProcPathEPciPKc
+            9700 _ZNK15google_breakpad17LinuxPtraceDumper13BuildProcPathEPciPKc.localalias.19
             97c0 _ZN15google_breakpad17LinuxPtraceDumper16EnumerateThreadsEv
             9e50 _ZN15google_breakpad17LinuxPtraceDumperC1Ei
             9e80 _ZN15google_breakpad17LinuxPtraceDumper15ReadRegisterSetEPNS_10ThreadInfoEi
             9f70 _ZN15google_breakpad17LinuxPtraceDumper13ReadRegistersEPNS_10ThreadInfoEi
             a050 _ZN15google_breakpad17LinuxPtraceDumper20GetThreadInfoByIndexEmPNS_10ThreadInfoE
             a690 _ZN15google_breakpad17LinuxPtraceDumper14ThreadsSuspendEv
-            a8f0 _ZN15google_breakpad17LinuxPtraceDumperD1Ev
+            a8f0 _ZN15google_breakpad17LinuxPtraceDumperD2Ev
             a910 _ZN15google_breakpad17LinuxPtraceDumperD0Ev
             a930 _ZNSt6vectorIiN15google_breakpad16PageStdAllocatorIiEEE17_M_default_appendEm
             abc0 _ZN12_GLOBAL__N_114MinidumpWriter21WriteThreadListStreamEP14MDRawDirectory.constprop.105
@@ -119,7 +118,7 @@ expression: FunctionsDebug(&symcache)
            11220 _ZN15google_breakpad8ElfClassEPKv
            11230 _ZN15google_breakpad14FindElfSectionEPKvPKcjPS1_Pm
            116a0 _ZN15google_breakpad15FindElfSegmentsEPKvjPNS_15wasteful_vectorINS_10ElfSegmentEEE
-           11990 _ZNSt6vectorIN15google_breakpad10ElfSegmentENS0_16PageStdAllocatorIS1_EEE19_M_emplace_back_auxIIRKS1_EEEvDpOT_
+           11990 _ZNSt6vectorIN15google_breakpad10ElfSegmentENS0_16PageStdAllocatorIS1_EEE19_M_emplace_back_auxIJRKS1_EEEvDpOT_
            11be0 _ZN15google_breakpad6FileIDC2EPKc
            11cc0 _ZN15google_breakpad6FileID29ConvertIdentifierToUUIDStringB5cxx11ERKNS_15wasteful_vectorIhEE
            11e70 _ZN15google_breakpad6FileID25ConvertIdentifierToStringB5cxx11ERKNS_15wasteful_vectorIhEE
@@ -145,11 +144,11 @@ expression: FunctionsDebug(&symcache)
            13160 my_isspace
            13210 _ZN15google_breakpad16MemoryMappedFileC2Ev
            13220 _ZN15google_breakpad16MemoryMappedFile5UnmapEv
-           13270 _ZN15google_breakpad16MemoryMappedFileD2Ev
+           13270 _ZN15google_breakpad16MemoryMappedFileD1Ev
            13280 _ZN15google_breakpad16MemoryMappedFile3MapEPKcm
-           13430 _ZN15google_breakpad16MemoryMappedFileC1EPKcm
+           13430 _ZN15google_breakpad16MemoryMappedFileC2EPKcm
            13450 _ZN15google_breakpad12SafeReadLinkEPKcPcm
-           13490 _ZN15google_breakpad12_GLOBAL__N_125CrashGenerationClientImplD1Ev
+           13490 _ZN15google_breakpad12_GLOBAL__N_125CrashGenerationClientImplD2Ev
            134a0 _ZN15google_breakpad12_GLOBAL__N_125CrashGenerationClientImpl11RequestDumpEPKvm
            136c0 _ZN15google_breakpad12_GLOBAL__N_125CrashGenerationClientImplD0Ev
            136d0 _ZN15google_breakpad21CrashGenerationClient9TryCreateEi
@@ -170,4 +169,3 @@ expression: FunctionsDebug(&symcache)
            14c30 __libc_csu_init
            14ca0 __libc_csu_fini
            14ca4 _fini
-
diff --git a/symbolic-symcache/tests/snapshots/test_writer__functions_macos.snap b/symbolic-symcache/tests/snapshots/test_writer__functions_macos.snap
index bbd0d8ba3..2a8cd5388 100644
--- a/symbolic-symcache/tests/snapshots/test_writer__functions_macos.snap
+++ b/symbolic-symcache/tests/snapshots/test_writer__functions_macos.snap
@@ -1,7 +1,6 @@
 ---
 source: symbolic-symcache/tests/test_writer.rs
 expression: FunctionsDebug(&symcache)
-
 ---
                0 _mh_execute_header
              d20 _ZN15google_breakpad18MinidumpFileWriterC2Ev
@@ -198,4 +197,3 @@ expression: FunctionsDebug(&symcache)
             db50 _ZN15google_breakpad14MachPortSender11SendMessageERNS_15MachSendMessageEj
             dba0 main
             dc70 _ZN12_GLOBAL__N_18callbackEPKcS1_Pvb
-
diff --git a/symbolic-symcache/tests/snapshots/test_writer__overlapping_funcs.snap b/symbolic-symcache/tests/snapshots/test_writer__overlapping_funcs.snap
index 2d945a11a..0c089a70f 100644
--- a/symbolic-symcache/tests/snapshots/test_writer__overlapping_funcs.snap
+++ b/symbolic-symcache/tests/snapshots/test_writer__overlapping_funcs.snap
@@ -1,7 +1,6 @@
 ---
 source: symbolic-symcache/tests/test_writer.rs
 expression: FunctionsDebug(&symcache)
-
 ---
                0 _mh_execute_header
             3f50 main
@@ -9,4 +8,3 @@ expression: FunctionsDebug(&symcache)
             3f90 unique_i_swear
             3fa0 spin
             3fb0 unique_i_swear
-
diff --git a/symbolic-symcache/tests/test_writer.rs b/symbolic-symcache/tests/test_writer.rs
index 95c08bc00..294638131 100644
--- a/symbolic-symcache/tests/test_writer.rs
+++ b/symbolic-symcache/tests/test_writer.rs
@@ -33,8 +33,8 @@ fn test_write_header_linux() -> Result<(), Error> {
         arch: Amd64,
         files: 55,
         functions: 697,
-        source_locations: 8284,
-        ranges: 6828,
+        source_locations: 8431,
+        ranges: 6975,
         string_bytes: 49877,
     }
     "#);
@@ -77,8 +77,8 @@ fn test_write_header_macos() -> Result<(), Error> {
         arch: Amd64,
         files: 36,
         functions: 639,
-        source_locations: 7199,
-        ranges: 5782,
+        source_locations: 7382,
+        ranges: 5965,
         string_bytes: 40958,
     }
     "#);
@@ -351,3 +351,34 @@ fn test_trailing_marker() -> Result<(), Error> {
 
     Ok(())
 }
+
+/// Tests that addresses between functions are unmapped. See
+/// <https://github.com/getsentry/symbolic/pull/897>.
+#[test]
+fn test_lookup_between_functions() {
+    // This file is a Python fixture
+    let buffer = ByteView::open(
+        "../py/tests/res/ext/1.4.1/release/dSYMs/3CD3E3CC-281E-3AF3-84EB-CDE6D56F0559.dSYM/Contents/Resources/DWARF/CrashLibiOS",
+    )
+    .unwrap();
+    let object = Object::parse(&buffer).unwrap();
+
+    let mut buffer = Vec::new();
+    let mut converter = SymCacheConverter::new();
+    converter.process_object(&object).unwrap();
+    converter.serialize(&mut Cursor::new(&mut buffer)).unwrap();
+    let symcache = SymCache::parse(&buffer).unwrap();
+    // This address is exactly at the end of the function "-[CRLCrashNXPage desc]",
+    // which starts at 0x8b0c and has size 0x2c. The next function,
+    // "-[CRLCrashStackGuard category]", starts at 0x8b3c.
+    //
+    // However, there is an entry in the symbol table for "-[CRLCrashNXPage crash]" starting
+    // at this address.
+    let symbols = symcache.lookup(0x8b38).collect::<Vec<_>>();
+    assert_eq!(symbols.len(), 1);
+
+    let function = symbols[0].function();
+
+    assert_eq!(function.name(), "-[CRLCrashNXPage crash]");
+    assert_eq!(function.entry_pc(), 0x8b38);
+}
diff --git a/symbolic-testutils/Cargo.toml b/symbolic-testutils/Cargo.toml
index 723cf37be..89634f10e 100644
--- a/symbolic-testutils/Cargo.toml
+++ b/symbolic-testutils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-testutils"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 edition = "2021"
 publish = false
diff --git a/symbolic-testutils/fixtures/linux/README.md b/symbolic-testutils/fixtures/linux/README.md
index f1850fd6d..6e2d8fb38 100644
--- a/symbolic-testutils/fixtures/linux/README.md
+++ b/symbolic-testutils/fixtures/linux/README.md
@@ -1,3 +1,5 @@
 The `crash.debug-z{lib,std}` files contain the exact same debug information as the `crash.debug` file they were derived from.
 
 The files were derived using `llvm-objcopy --compress-debug-sections=z{lib,std} crash.debug crash.debug-z{lib,std}` respectively.
+
+`dynsyms_only` is an ELF file that only contains a dynamic symbol table obtained using `llvm-objcopy --only-keep-debug --set-section-type .dynstr=3 --set-section-type .dynsym=11 linux-vdso.1.so dynsyms_only`.
diff --git a/symbolic-testutils/fixtures/linux/dynsyms_only b/symbolic-testutils/fixtures/linux/dynsyms_only
new file mode 100644
index 000000000..c24be5249
Binary files /dev/null and b/symbolic-testutils/fixtures/linux/dynsyms_only differ
diff --git a/symbolic-testutils/fixtures/windows/crash_with_srcsrv.pdb b/symbolic-testutils/fixtures/windows/crash_with_srcsrv.pdb
new file mode 100755
index 000000000..18f4e3ccb
Binary files /dev/null and b/symbolic-testutils/fixtures/windows/crash_with_srcsrv.pdb differ
diff --git a/symbolic-unreal/Cargo.toml b/symbolic-unreal/Cargo.toml
index 8c8ecc26c..ec0f284ca 100644
--- a/symbolic-unreal/Cargo.toml
+++ b/symbolic-unreal/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic-unreal"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 authors = [
     "Armin Ronacher <armin.ronacher@active-4.com>",
@@ -13,7 +13,8 @@ repository = "https://github.com/getsentry/symbolic"
 description = """
 Parsing and processing utilities for Unreal Engine 4 crash files.
 """
-edition = "2021"
+edition.workspace = true
+rust-version.workspace = true
 
 exclude = ["tests/**/*"]
 
diff --git a/symbolic/Cargo.toml b/symbolic/Cargo.toml
index b5aa2e4e6..1a5ee9ef7 100644
--- a/symbolic/Cargo.toml
+++ b/symbolic/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "symbolic"
-version = "12.9.2-dd"
+version = "12.17.0-dd"
 license = "MIT"
 authors = [
     "Armin Ronacher <armin.ronacher@active-4.com>",
@@ -14,7 +14,8 @@ description = """
 A library to symbolicate and process stack traces from native applications,
 minidumps, Unreal Engine 4 or minified JavaScript.
 """
-edition = "2021"
+edition.workspace = true
+rust-version.workspace = true
 
 [package.metadata.docs.rs]
 all-features = true
@@ -34,12 +35,12 @@ unreal = ["symbolic-unreal"]
 unreal-serde = ["unreal", "common-serde", "symbolic-unreal/serde"]
 
 [dependencies]
-symbolic-cfi = { version = "12.9.2-dd", path = "../symbolic-cfi", optional = true }
-symbolic-common = { version = "12.9.2-dd", path = "../symbolic-common" }
-symbolic-debuginfo = { version = "12.9.2-dd", path = "../symbolic-debuginfo", optional = true }
-symbolic-demangle = { version = "12.9.2-dd", path = "../symbolic-demangle", optional = true }
-symbolic-il2cpp = { version = "12.9.2-dd", path = "../symbolic-il2cpp", optional = true }
-symbolic-ppdb = { version = "12.9.2-dd", path = "../symbolic-ppdb", optional = true }
-symbolic-sourcemapcache = { version = "12.9.2-dd", path = "../symbolic-sourcemapcache", optional = true }
-symbolic-symcache = { version = "12.9.2-dd", path = "../symbolic-symcache", optional = true }
-symbolic-unreal = { version = "12.9.2-dd", path = "../symbolic-unreal", optional = true }
+symbolic-cfi = { version = "12.17.0-dd", path = "../symbolic-cfi", optional = true }
+symbolic-common = { version = "12.17.0-dd", path = "../symbolic-common" }
+symbolic-debuginfo = { version = "12.17.0-dd", path = "../symbolic-debuginfo", optional = true }
+symbolic-demangle = { version = "12.17.0-dd", path = "../symbolic-demangle", optional = true }
+symbolic-il2cpp = { version = "12.17.0-dd", path = "../symbolic-il2cpp", optional = true }
+symbolic-ppdb = { version = "12.17.0-dd", path = "../symbolic-ppdb", optional = true }
+symbolic-sourcemapcache = { version = "12.17.0-dd", path = "../symbolic-sourcemapcache", optional = true }
+symbolic-symcache = { version = "12.17.0-dd", path = "../symbolic-symcache", optional = true }
+symbolic-unreal = { version = "12.17.0-dd", path = "../symbolic-unreal", optional = true }