multi-demangle 2.0.1__tar.gz → 2.1.0__tar.gz

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/Cargo.lock

@@ -359,7 +359,7 @@ dependencies = [
 
 [[package]]
 name = "multi-demangle"
-version = "2.0.1"
+version = "2.1.0"
 dependencies = [
  "cc",
  "clap",

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "multi-demangle"
-version = "2.0.1"
+version = "2.1.0"
 license = "MIT"
 authors = [
     "Team AppThreat <cloud@appthreat.com>"

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-demangle
-Version: 2.0.1
+Version: 2.1.0
 License-File: LICENSE
 Summary: A library to demangle symbols from various languages and compilers.
 Keywords: demangler,binary
@@ -22,7 +22,7 @@ Currently supported languages are:
 | C++           | Itanium ABI (GCC, Clang), GNU v2, CodeWarrior, and MSVC                                                            | `cpp`, `gnuv2`, `codewarrior`, `msvc` |
 | Rust          | Both `legacy` and `v0` schemes                                                                                     | `rust`                                |
 | Scala Native  | Via the unknown-language fallback (symbols prefixed `_SM`)                                                         | `scala-native`                        |
-| Swift         | Up to Swift 6.3.3, using a vendored Swift demangler                                                                | `swift`                               |
+| Swift         | Up to Swift 6.4.0, using a vendored Swift demangler                                                                | `swift`                               |
 | D             | D ABI mangling (`_D…`), incl. function types and templates                                                         | `dlang`                               |
 | Fortran       | gfortran `mod_MOD_proc`, Intel `mod_mp_proc_`, and the plain g77 `name_` form — **explicit request only** (see below)  | `fortran`                             |
 | Kotlin/Native | `_kfun:` symbols with parameter types                                                                              | `kotlin-native`                       |
@@ -607,8 +607,16 @@ The supported-version claim above is backed by per-toolchain corpus snapshots:
 `scripts/collect-swift-corpus.sh` compiles a fixture with a concrete Swift
 toolchain (pass its `swiftc` to represent another one) into
 `tests/corpus/swift/<version>/`, and the `swift_corpus` test pins the exact
-rendering. After a sync that changes output, regenerate snapshots deliberately
-and review the diff — downstream consumers (blint) match on these strings:
+rendering. The fixture exercises the constructs whose manglings drift between
+toolchains; Swift 6.4 additions (SE-0507 borrow/mutate accessors, SE-0521
+optional opaque types, SE-0474 yielding accessors) are guarded with
+`#if compiler(>=6.4)`, and the script retries the compile with
+`-enable-experimental-feature CoroutineAccessors` when the toolchain gates the
+yielding accessors (recorded in the corpus `provenance.txt`). After a sync
+that changes output, regenerate snapshots deliberately and review the diff —
+downstream consumers (blint) match on these strings. Note that Swift 6.4
+renamed the rendering of the coroutine accessors: symbols that printed as
+`.read2`/`.modify2` now print as `.yielding_borrow`/`.yielding_mutate`.
 
 ```
 MULTI_DEMANGLE_UPDATE_SNAPSHOTS=1 cargo test --all-features --test test_swift_corpus

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/README.md

@@ -12,7 +12,7 @@ Currently supported languages are:
 | C++           | Itanium ABI (GCC, Clang), GNU v2, CodeWarrior, and MSVC                                                            | `cpp`, `gnuv2`, `codewarrior`, `msvc` |
 | Rust          | Both `legacy` and `v0` schemes                                                                                     | `rust`                                |
 | Scala Native  | Via the unknown-language fallback (symbols prefixed `_SM`)                                                         | `scala-native`                        |
-| Swift         | Up to Swift 6.3.3, using a vendored Swift demangler                                                                | `swift`                               |
+| Swift         | Up to Swift 6.4.0, using a vendored Swift demangler                                                                | `swift`                               |
 | D             | D ABI mangling (`_D…`), incl. function types and templates                                                         | `dlang`                               |
 | Fortran       | gfortran `mod_MOD_proc`, Intel `mod_mp_proc_`, and the plain g77 `name_` form — **explicit request only** (see below)  | `fortran`                             |
 | Kotlin/Native | `_kfun:` symbols with parameter types                                                                              | `kotlin-native`                       |
@@ -597,8 +597,16 @@ The supported-version claim above is backed by per-toolchain corpus snapshots:
 `scripts/collect-swift-corpus.sh` compiles a fixture with a concrete Swift
 toolchain (pass its `swiftc` to represent another one) into
 `tests/corpus/swift/<version>/`, and the `swift_corpus` test pins the exact
-rendering. After a sync that changes output, regenerate snapshots deliberately
-and review the diff — downstream consumers (blint) match on these strings:
+rendering. The fixture exercises the constructs whose manglings drift between
+toolchains; Swift 6.4 additions (SE-0507 borrow/mutate accessors, SE-0521
+optional opaque types, SE-0474 yielding accessors) are guarded with
+`#if compiler(>=6.4)`, and the script retries the compile with
+`-enable-experimental-feature CoroutineAccessors` when the toolchain gates the
+yielding accessors (recorded in the corpus `provenance.txt`). After a sync
+that changes output, regenerate snapshots deliberately and review the diff —
+downstream consumers (blint) match on these strings. Note that Swift 6.4
+renamed the rendering of the coroutine accessors: symbols that printed as
+`.read2`/`.modify2` now print as `.yielding_borrow`/`.yielding_mutate`.
 
 ```
 MULTI_DEMANGLE_UPDATE_SNAPSHOTS=1 cargo test --all-features --test test_swift_corpus

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/build.rs

@@ -13,7 +13,7 @@ fn main() {
             "vendor/swift/lib/Demangling/NodePrinter.cpp",
             "vendor/swift/lib/Demangling/Punycode.cpp",
             "vendor/swift/lib/Demangling/Remangler.cpp",
-            "vendor/swift/lib/Demangling/Errors.cpp",
+            "vendor/swift/lib/Demangling/DemanglingErrorHandling.cpp",
         ];
 
         cc::Build::new()

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "multi-demangle"
-version = "2.0.1"
+version = "2.1.0"
 description = "A library to demangle symbols from various languages and compilers."
 readme = "README.md"
 license = "MIT"

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/scripts/collect-swift-corpus.sh

@@ -64,7 +64,20 @@ trap 'rm -rf "$TMP"' EXIT
 # Internal (non-public) symbols are exactly what the demangler sees in real
 # binaries' symtabs, so no visibility gymnastics are needed; -parse-as-library
 # keeps top-level code out of the way of actors/global-actor isolation.
-"$SWIFTC" -c -parse-as-library -o "$TMP/fixture.o" "$FIXTURE"
+# Swift 6.4 gates the fixture's yielding accessors (SE-0474) behind an
+# experimental feature flag; when the plain compile rejects them, retry with
+# the flag and record it in the provenance so the corpus stays reproducible.
+EXTRA_FLAGS=""
+if ! "$SWIFTC" -c -parse-as-library -o "$TMP/fixture.o" "$FIXTURE" 2>"$TMP/compile.log"; then
+    if "$SWIFTC" -c -parse-as-library \
+        -enable-experimental-feature CoroutineAccessors \
+        -o "$TMP/fixture.o" "$FIXTURE" 2>"$TMP/compile-flag.log"; then
+        EXTRA_FLAGS="-enable-experimental-feature CoroutineAccessors"
+    else
+        cat "$TMP/compile-flag.log" >&2
+        exit 1
+    fi
+fi
 
 # Collect into the temp dir and only publish a corpus that passed the checks
 # below: writing straight to $OUT_DIR would truncate the committed snapshot
@@ -92,6 +105,7 @@ COUNT="$(grep -c '' < "$TMP/symbols.txt")"
     echo "target: $("$SWIFTC" -print-target-info 2>/dev/null \
         | sed -n 's/.*"unversionedTriple"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -1)"
     echo "source: scripts/swift-corpus-fixture.swift compiled with $SWIFTC"
+    [ -z "$EXTRA_FLAGS" ] || echo "flags: $EXTRA_FLAGS"
 } > "$TMP/provenance.txt"
 
 mv "$TMP/symbols.txt" "$OUT_DIR/symbols.txt"

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/scripts/swift-corpus-fixture.swift

@@ -7,6 +7,14 @@
 // between toolchains: generics and associated types, closures (escaping,
 // autoclosure, @Sendable), async/await and throw, actors and global-actor
 // isolation, property wrappers, subscripts, and specialization attributes.
+//
+// Swift 6.4 additions (SE-0507 borrow/mutate accessors, SE-0521 optional
+// opaque/existential types, SE-0474 yielding accessors, SE-0493/SE-0504
+// async-defer and cancellation shielding) are guarded with
+// `#if compiler(>=6.4)` so the fixture still compiles with the 6.3.x
+// toolchains that back the older corpora. The yielding accessors additionally
+// need `-enable-experimental-feature CoroutineAccessors`, which
+// collect-swift-corpus.sh passes automatically when the toolchain accepts it.
 
 import Foundation
 
@@ -149,3 +157,58 @@ extension Packet: CustomStringConvertible {
 
 @discardableResult
 func discardable(_ flag: Bool) -> Int { flag ? 1 : 0 }
+
+// --- Swift 6.4 ---
+
+#if compiler(>=6.4)
+// nonisolated(nonsending) parameter isolation: the closure type mangles with
+// the NonIsolatedCallerFunctionType marker ('C').
+actor Queue {
+    func enqueue(_ op: nonisolated(nonsending) () async -> Void) async {
+        await op()
+    }
+}
+// SE-0507 borrow/mutate accessors on a Copyable type: the accessors mangle
+// with the borrow ('b') and mutate ('z') accessor letters.
+struct Gauge64 {
+    private var backing: Int = 7
+    var direct: Int {
+        borrow { backing }
+        mutate { &backing }
+    }
+}
+
+// SE-0507 accessors on a ~Copyable type (the proposal's motivating form).
+struct Rigid<Element: ~Copyable>: ~Copyable {
+    var _element: Element
+    var element: Element {
+        borrow {
+            return _element
+        }
+        mutate {
+            return &_element
+        }
+    }
+}
+
+// SE-0521: optional opaque and existential types without parentheses.
+func optionalOpaque64(_ p: Packet) -> some Payload? { p }
+func optionalAny64(_ p: (any Payload)?) -> any Payload? { p }
+
+// SE-0474 yielding accessors (experimental in 6.4): the coroutine accessors
+// mangle as YieldingBorrowAccessor ('y') / YieldingMutateAccessor ('x').
+struct Yielder {
+    private var storage: [Int] = [1, 2, 3]
+    var current: Int {
+        yielding borrow { yield storage[0] }
+        yielding mutate { yield &storage[0] }
+    }
+}
+
+// SE-0493: defer in async code runs (and is awaited) before the function
+// exits. No dedicated mangling, but it exercises 6.4 codegen for the corpus.
+func deferredAsync(_ flag: Bool) async -> Int {
+    defer { print("exiting") }
+    return flag ? 1 : 0
+}
+#endif

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/scripts/sync-swift.sh

@@ -48,7 +48,7 @@ LLVM_SPARSE=(
 
 # build.rs compiles these lib/Demangling translation units; CrashReporter.cpp
 # is intentionally omitted (SWIFT_RUNTIME_NO_CRASH_REPORTER).
-BUILD_CPP="Context.cpp Demangler.cpp ManglingUtils.cpp NodeDumper.cpp NodePrinter.cpp Punycode.cpp Remangler.cpp Errors.cpp"
+BUILD_CPP="Context.cpp Demangler.cpp ManglingUtils.cpp NodeDumper.cpp NodePrinter.cpp Punycode.cpp Remangler.cpp DemanglingErrorHandling.cpp"
 
 FORCE=0
 TAG=""

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/src/lib.rs

@@ -5,7 +5,7 @@
 //! - C++ (Itanium, GNU v2, CodeWarrior, and MSVC) (`features = ["cpp", "gnuv2", "codewarrior", "msvc"]`)
 //! - Rust (both `legacy` and `v0`) (`features = ["rust"]`)
 //! - Scala Native via the unknown-language fallback (`features = ["scala-native"]`)
-//! - Swift (up to Swift 6.3.3) (`features = ["swift"]`)
+//! - Swift (up to Swift 6.4.0) (`features = ["swift"]`)
 //! - D (`features = ["dlang"]`)
 //! - Fortran, gfortran and Intel module symbols plus the plain g77 `name_`
 //!   form — explicit-request-only (`features = ["fortran"]`)

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/src/structured/swift.rs

@@ -55,9 +55,10 @@ const ACCESSOR_KINDS: &[&str] = &[
     "Setter",
     "MaterializeForSet",
     "ModifyAccessor",
-    "Modify2Accessor",
+    // Renamed from Modify2Accessor/Read2Accessor at Swift 6.4 (SE-0474).
+    "YieldingMutateAccessor",
     "ReadAccessor",
-    "Read2Accessor",
+    "YieldingBorrowAccessor",
     "WillSet",
     "DidSet",
     "OwningAddressor",

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/vendor/swift/MANIFEST.txt

@@ -56,7 +56,7 @@ include/swift/Strings.h
 lib/Demangling/Context.cpp
 lib/Demangling/Demangler.cpp
 lib/Demangling/DemanglerAssert.h
-lib/Demangling/Errors.cpp
+lib/Demangling/DemanglingErrorHandling.cpp
 lib/Demangling/ManglingUtils.cpp
 lib/Demangling/NodeDumper.cpp
 lib/Demangling/NodePrinter.cpp

multi_demangle-2.1.0/vendor/swift/SYNC.md

@@ -0,0 +1,62 @@
+# Swift vendor sync log
+
+Records of every `vendor/swift` sync from upstream Swift, produced by
+`scripts/sync-swift.sh <swift-tag>` (run it rather than editing by hand).
+Each entry lists the upstream refs, what changed in the vendored subset,
+the diffstat, and the validation results. The `sync-metadata` block at the
+bottom always describes the most recent sync; the monthly CI reminder
+workflow parses it to list upstream commits since the last sync.
+
+## 2026-08-29 — swift-6.3.3-RELEASE
+
+- Swift ref: swift-6.3.3-RELEASE (064859e41d68596f486c5d724401cb370f260409)
+- LLVM ref: swift-6.3.3-RELEASE (82cdc19fa54d566969527b56f587ea8ea30bef51)
+- Headers added to the manifest: none
+- Manifest files missing upstream: none
+- Diffstat:  18 files changed, 3023 insertions(+), 1481 deletions(-)
+- New files:
+  vendor/swift/SYNC.md
+  vendor/swift/include/llvm-c/
+  vendor/swift/include/llvm/ADT/ADL.h
+  vendor/swift/include/llvm/ADT/DenseMapInfo.h
+  vendor/swift/include/llvm/ADT/STLForwardCompat.h
+  vendor/swift/include/llvm/ADT/STLFunctionalExtras.h
+  vendor/swift/include/llvm/ADT/bit.h
+  vendor/swift/include/llvm/Config/
+  vendor/swift/include/llvm/Support/DataTypes.h
+- Validation: cargo test --all-features PASS; pytest PASS; ASan/UBSan corpus PASS
+
+
+## 2026-09-15 — swift-6.4.0-RELEASE
+
+- Swift ref: swift-6.4.0-RELEASE (b8189d766d86ad7fc8106787d6ce9e402f38dd72)
+- LLVM ref: swift-6.4.0-RELEASE (903b9faaae5c43ecc9b7e33f8db9c94c7429374a)
+- Headers added to the manifest: none
+- Manifest files missing upstream: lib/Demangling/Errors.cpp — renamed upstream
+  to lib/Demangling/DemanglingErrorHandling.cpp (byte-identical modulo the
+  header comment); vendored under the new name, dropped the old one, and
+  updated build.rs/scripts accordingly
+- Diffstat:  10 files changed, 137 insertions(+), 26 deletions(-)
+- Mangling changes: Read2Accessor/Modify2Accessor renamed to
+  YieldingBorrowAccessor/YieldingMutateAccessor (printed `yielding_borrow`/
+  `yielding_mutate`, SE-0474); new BuiltinBorrow node (`BW`, SE-0507);
+  new ImplNonisolatedNonsendingIsolation impl-function-type flag (`N`,
+  printed `@caller_isolated`); new EscapingClosureProp function-signature
+  specialization parameter (`E`); inverse requirements on associated types
+  (`j`/`J`)
+- New files:
+  vendor/swift/lib/Demangling/DemanglingErrorHandling.cpp
+- Validation: cargo test --all-features PASS; pytest PASS (run after the
+  sync — the script skipped it because the venv lacked maturin at the time);
+  ASan/UBSan corpus PASS (including the new tests/corpus/swift/6.4.0 corpus);
+  added per-toolchain corpus tests/corpus/swift/6.4.0 (Apple Swift 6.4.0,
+  arm64-apple-macosx, with -enable-experimental-feature CoroutineAccessors
+  for the fixture's SE-0474 accessors)
+
+<!-- sync-metadata
+swift-ref: swift-6.4.0-RELEASE
+swift-commit: b8189d766d86ad7fc8106787d6ce9e402f38dd72
+llvm-ref: swift-6.4.0-RELEASE
+llvm-commit: 903b9faaae5c43ecc9b7e33f8db9c94c7429374a
+date: 2026-09-15
+-->

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/vendor/swift/include/llvm/ADT/Hashing.h

@@ -329,7 +329,7 @@ struct hash_state {
 /// This variable can be set using the \see llvm::set_fixed_execution_seed
 /// function. See that function for details. Do not, under any circumstances,
 /// set or read this variable.
-extern uint64_t fixed_seed_override;
+LLVM_ABI extern uint64_t fixed_seed_override;
 
 inline uint64_t get_execution_seed() {
   // FIXME: This needs to be a per-execution seed. This is just a placeholder

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/vendor/swift/include/llvm/ADT/StringRef.h

@@ -38,6 +38,8 @@ namespace llvm {
   LLVM_ABI bool getAsSignedInteger(StringRef Str, unsigned Radix,
                                    long long &Result);
 
+  LLVM_ABI unsigned getAutoSenseRadix(StringRef &Str);
+
   LLVM_ABI bool consumeUnsignedInteger(StringRef &Str, unsigned Radix,
                                        unsigned long long &Result);
   LLVM_ABI bool consumeSignedInteger(StringRef &Str, unsigned Radix,

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/vendor/swift/include/swift/AST/Ownership.h

@@ -153,7 +153,7 @@ ValueOwnership asValueOwnership(ParameterOwnership o);
 static inline llvm::StringRef getOwnershipSpelling(ValueOwnership ownership) {
   switch (ownership) {
   case ValueOwnership::Default:
-    return "";
+    return "default";
   case ValueOwnership::InOut:
     return "inout";
   case ValueOwnership::Shared:

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/vendor/swift/include/swift/Demangling/Demangle.h

@@ -118,6 +118,7 @@ enum class FunctionSigSpecializationParamKind : unsigned {
   ConstantPropKeyPath = 9,
   ConstantPropStruct = 10,
   ClosurePropPreviousArg = 11,
+  EscapingClosureProp = 12,
 
   // Option Set Flags use bits 6-31. This gives us 26 bits to use for option
   // flags.

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/vendor/swift/include/swift/Demangling/DemangleNodes.def

@@ -47,6 +47,7 @@ NODE(BoundGenericFunction)
 NODE(BuiltinTypeName)
 NODE(BuiltinTupleType)
 NODE(BuiltinFixedArray)
+NODE(BuiltinBorrow)
 NODE(CFunctionPointer)
 NODE(ClangType)
 CONTEXT_NODE(Class)
@@ -134,6 +135,7 @@ CONTEXT_NODE(IVarDestroyer)
 NODE(ImplEscaping)
 NODE(ImplConvention)
 NODE(ImplDifferentiabilityKind)
+NODE(ImplNonisolatedNonsendingIsolation)
 NODE(ImplErasedIsolation)
 NODE(ImplSendingResult)
 NODE(ImplParameterResultDifferentiability)
@@ -186,7 +188,7 @@ NODE(ObjCMetadataUpdateFunction)
 NODE(ObjCResilientClassStub)
 NODE(FullObjCResilientClassStub)
 CONTEXT_NODE(ModifyAccessor)
-CONTEXT_NODE(Modify2Accessor)
+CONTEXT_NODE(YieldingMutateAccessor)
 CONTEXT_NODE(Module)
 CONTEXT_NODE(NativeOwningAddressor)
 CONTEXT_NODE(NativeOwningMutableAddressor)
@@ -240,7 +242,7 @@ NODE(ReabstractionThunkHelper)
 NODE(ReabstractionThunkHelperWithSelf)
 NODE(ReabstractionThunkHelperWithGlobalActor)
 CONTEXT_NODE(ReadAccessor)
-CONTEXT_NODE(Read2Accessor)
+CONTEXT_NODE(YieldingBorrowAccessor)
 NODE(RelatedEntityDeclName)
 NODE(RetroactiveConformance)
 NODE(ReturnType)

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/vendor/swift/include/swift/Demangling/Demangler.h

@@ -496,6 +496,7 @@ protected:
     Vector<NodePointer> NodeStack;
     Vector<NodePointer> Substitutions;
     int NumWords;
+    StringRef Words[MaxNumWords];
     StringRef Text;
     size_t Pos;
     std::function<SymbolicReferenceResolver_t> SymbolicReferenceResolver;
@@ -592,6 +593,7 @@ protected:
 
   NodePointer popAssocTypeName();
   NodePointer popAssocTypePath();
+  NodePointer popAssociatedConformanceWitnessAccessorSubject();
   NodePointer getDependentGenericParamType(int depth, int index);
   NodePointer demangleGenericParamIndex();
   NodePointer popProtocolConformance();

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/vendor/swift/include/swift/Strings.h

@@ -37,6 +37,8 @@ constexpr static const StringLiteral SWIFT_STRING_PROCESSING_NAME = "_StringProc
 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 CxxStdlibShim module, which contains utilities for the C++ stdlib overlay.
+constexpr static const StringLiteral CXX_STDLIB_SHIM_NAME = "CxxStdlibShim";
 /// 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.
@@ -178,6 +180,8 @@ constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_VEC = {
     "Builtin.Vec"};
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_FIXEDARRAY = {
     "Builtin.FixedArray"};
+constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_BORROW = {
+    "Builtin.Borrow"};
 /// The name of the Builtin type for SILToken
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_SILTOKEN = {
     "Builtin.SILToken"};

{multi_demangle-2.0.1 → multi_demangle-2.1.0}/vendor/swift/lib/Demangling/Demangler.cpp

@@ -14,7 +14,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Support/Compiler.h"
 #include "swift/Demangling/Demangler.h"
 #include "DemanglerAssert.h"
 #include "swift/Demangling/ManglingMacros.h"
@@ -301,6 +300,20 @@ static bool isProtocolNode(Demangle::NodePointer Node) {
   assert(0 && "unknown node kind");
 }
 
+static bool isGenericParamType(Demangle::NodePointer Node) {
+  if (!Node)
+    return false;
+  switch (Node->getKind()) {
+  case Demangle::Node::Kind::Type:
+    return isGenericParamType(Node->getChild(0));
+  case Demangle::Node::Kind::DependentGenericParamType:
+    return true;
+  default:
+    return false;
+  }
+  assert(0 && "unknown node kind");
+}
+
 bool swift::Demangle::isProtocol(llvm::StringRef mangledName) {
   Demangle::Demangler Dem;
   return isProtocolNode(Dem.demangleType(dropSwiftManglingPrefix(mangledName)));
@@ -722,6 +735,7 @@ Demangler::DemangleInitRAII::DemangleInitRAII(Demangler &Dem,
     NumWords(Dem.NumWords), Text(Dem.Text), Pos(Dem.Pos),
     SymbolicReferenceResolver(std::move(Dem.SymbolicReferenceResolver))
 {
+  std::copy(Dem.Words, Dem.Words + MaxNumWords, Words);
   // Reset the demangler state for a nested job.
   Dem.NodeStack.init(Dem, 16);
   Dem.Substitutions.init(Dem, 16);
@@ -736,6 +750,7 @@ Demangler::DemangleInitRAII::~DemangleInitRAII() {
   Dem.NodeStack = NodeStack;
   Dem.Substitutions = Substitutions;
   Dem.NumWords = NumWords;
+  std::copy(Words, Words + MaxNumWords, Dem.Words);
   Dem.Text = Text;
   Dem.Pos = Pos;
   Dem.SymbolicReferenceResolver = std::move(SymbolicReferenceResolver);
@@ -1510,6 +1525,14 @@ NodePointer Demangler::demangleBuiltinType() {
       Ty->addChild(element, *this);
       break;
     }
+    case 'W': {
+      NodePointer referent = popNode(Node::Kind::Type);
+      if (!referent)
+        return nullptr;
+      Ty = createNode(Node::Kind::BuiltinBorrow);
+      Ty->addChild(referent, *this);
+      break;
+    }
     case 'O':
       Ty = createNode(Node::Kind::BuiltinTypeName,
                                BUILTIN_TYPE_NAME_UNKNOWNOBJECT);
@@ -2402,6 +2425,10 @@ NodePointer Demangler::demangleImplFunctionType() {
   if (nextIf('A'))
     type->addChild(createNode(Node::Kind::ImplErasedIsolation), *this);
 
+  if (nextIf('N'))
+    type->addChild(createNode(Node::Kind::ImplNonisolatedNonsendingIsolation),
+                   *this);
+
   switch ((MangledDifferentiabilityKind)peekChar()) {
   case MangledDifferentiabilityKind::Normal:  // 'd'
   case MangledDifferentiabilityKind::Linear:  // 'l'
@@ -2905,6 +2932,16 @@ NodePointer Demangler::popProtocolConformance() {
   return Conf;
 }
 
+NodePointer Demangler::popAssociatedConformanceWitnessAccessorSubject() {
+  if (auto type = popNode(Node::Kind::Type)) {
+    if (isGenericParamType(type))
+      return type;
+
+    pushNode(type);
+  }
+  return popAssocTypePath();
+}
+
 NodePointer Demangler::demangleThunkOrSpecialization() {
   switch (char c = nextChar()) {
     // Thunks that are from a thunk inst. We take the TT namespace.
@@ -3080,19 +3117,19 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
 
     case 'n': {
       NodePointer requirementTy = popProtocol();
-      NodePointer conformingType = popAssocTypePath();
+      NodePointer subject = popAssociatedConformanceWitnessAccessorSubject();
       NodePointer protoTy = popNode(Node::Kind::Type);
       return createWithChildren(Node::Kind::AssociatedConformanceDescriptor,
-                                protoTy, conformingType, requirementTy);
+                                protoTy, subject, requirementTy);
     }
 
     case 'N': {
       NodePointer requirementTy = popProtocol();
-      auto assocTypePath = popAssocTypePath();
+      NodePointer subject = popAssociatedConformanceWitnessAccessorSubject();
       NodePointer protoTy = popNode(Node::Kind::Type);
       return createWithChildren(
                             Node::Kind::DefaultAssociatedConformanceAccessor,
-                            protoTy, assocTypePath, requirementTy);
+                            protoTy, subject, requirementTy);
     }
 
     case 'b': {
@@ -3403,7 +3440,8 @@ NodePointer Demangler::demangleFunctionSpecialization() {
 
       auto ParamKind = (FunctionSigSpecializationParamKind)KindNd->getIndex();
       switch (ParamKind) {
-        case FunctionSigSpecializationParamKind::ClosureProp: {
+        case FunctionSigSpecializationParamKind::ClosureProp:
+        case FunctionSigSpecializationParamKind::EscapingClosureProp: {
           while (NodePointer Ty = popNode(Node::Kind::Type)) {
             paramToAdd = addChild(paramToAdd, Ty);
           }
@@ -3445,6 +3483,12 @@ NodePointer Demangler::demangleFuncSpecParam(Node::Kind Kind) {
       return addChild(Param, createNode(
         Node::Kind::FunctionSignatureSpecializationParamKind,
         uint64_t(FunctionSigSpecializationParamKind::ClosureProp)));
+    case 'E':
+      // Like 'c', but for escaping closures. Consumes an identifier and
+      // multiple type parameters. The parameters will be added later.
+      return addChild(Param, createNode(
+        Node::Kind::FunctionSignatureSpecializationParamKind,
+        uint64_t(FunctionSigSpecializationParamKind::EscapingClosureProp)));
     case 'C': {
       // Consumes an identifier and multiple type parameters.
       // The parameters will be added later.
@@ -4123,9 +4167,9 @@ NodePointer Demangler::demangleAccessor(NodePointer ChildNode) {
     case 'w': Kind = Node::Kind::WillSet; break;
     case 'W': Kind = Node::Kind::DidSet; break;
     case 'r': Kind = Node::Kind::ReadAccessor; break;
-    case 'y': Kind = Node::Kind::Read2Accessor; break;
+    case 'y': Kind = Node::Kind::YieldingBorrowAccessor; break;
     case 'M': Kind = Node::Kind::ModifyAccessor; break;
-    case 'x': Kind = Node::Kind::Modify2Accessor; break;
+    case 'x': Kind = Node::Kind::YieldingMutateAccessor; break;
     case 'i': Kind = Node::Kind::InitAccessor; break;
     case 'b':
       Kind = Node::Kind::BorrowAccessor;
@@ -4397,6 +4441,20 @@ NodePointer Demangler::demangleGenericRequirement() {
       if (!inverseKind)
         return nullptr;
       break;
+    case 'j':
+      ConstraintKind = Inverse;
+      TypeKind = Assoc;
+      inverseKind = demangleIndexAsNode();
+      if (!inverseKind)
+        return nullptr;
+      break;
+    case 'J':
+      ConstraintKind = Inverse;
+      TypeKind = CompoundAssoc;
+      inverseKind = demangleIndexAsNode();
+      if (!inverseKind)
+        return nullptr;
+      break;
     default:  ConstraintKind = Protocol; TypeKind = Generic; pushBack(); break;
   }
 

multi_demangle-2.0.1/vendor/swift/lib/Demangling/Errors.cpp → multi_demangle-2.1.0/vendor/swift/lib/Demangling/DemanglingErrorHandling.cpp

@@ -1,4 +1,4 @@
-//===--- Errors.cpp - Demangling library error handling ---------*- C++ -*-===//
+//===-- DemanglingErrorHandling.cpp - Demangling library error handling ---===//
 //
 // This source file is part of the Swift.org open source project
 //