Merge pull request #3504 from swiftwasm/main

pull[bot] · web-flow · commit e9a268aee9ff · 2021-09-10T20:12:10.000Z
[pull] swiftwasm from main
diff --git a/include/swift/AST/ASTMangler.h b/include/swift/AST/ASTMangler.h
@@ -56,6 +56,10 @@ class ASTMangler : public Mangler {
   /// to fill these in.
   bool AllowSymbolicReferences = false;
 
+  /// If enabled, allows the use of standard substitutions for types in the
+  /// concurrency library.
+  bool AllowConcurrencyStandardSubstitutions = true;
+
 public:
   using SymbolicReferent = llvm::PointerUnion<const NominalTypeDecl *,
                                               const OpaqueTypeDecl *>;
diff --git a/include/swift/Demangling/ManglingUtils.h b/include/swift/Demangling/ManglingUtils.h
@@ -99,7 +99,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.
+llvm::Optional<StringRef> getStandardTypeSubst(
+    StringRef TypeName, bool allowConcurrencyManglings);
 
 /// Mangles an identifier using a generic Mangler class.
 ///
diff --git a/include/swift/Demangling/StandardTypesMangling.def b/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,25 @@ 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, 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/include/swift/SIL/MemAccessUtils.h b/include/swift/SIL/MemAccessUtils.h
@@ -171,6 +171,9 @@ SILValue getAccessBase(SILValue address);
 /// AccessedStorage::getRoot() and AccessPath::getRoot().
 SILValue findReferenceRoot(SILValue ref);
 
+/// Find the first owned root of the reference.
+SILValue findOwnershipReferenceRoot(SILValue ref);
+
 /// Return true if \p address points to a let-variable.
 ///
 /// let-variables are only written during let-variable initialization, which is
@@ -1264,9 +1267,13 @@ SILBasicBlock::iterator removeBeginAccess(BeginAccessInst *beginAccess);
 
 namespace swift {
 
-/// Return true if \p svi is a cast that preserves the identity and
+/// Return true if \p svi is a cast that preserves the identity equivalence of
+/// the reference at operand zero.
+bool isIdentityPreservingRefCast(SingleValueInstruction *svi);
+
+/// Return true if \p svi is a cast that preserves the identity equivalence and
 /// reference-counting equivalence of the reference at operand zero.
-bool isRCIdentityPreservingCast(SingleValueInstruction *svi);
+bool isIdentityAndOwnershipPreservingRefCast(SingleValueInstruction *svi);
 
 /// If \p svi is an access projection, return an address-type operand for the
 /// incoming address.
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -2973,7 +2973,8 @@ bool ASTMangler::tryAppendStandardSubstitution(const GenericTypeDecl *decl) {
     return false;
 
   if (isa<NominalTypeDecl>(decl)) {
-    if (auto Subst = getStandardTypeSubst(decl->getName().str())) {
+    if (auto Subst = getStandardTypeSubst(
+            decl->getName().str(), AllowConcurrencyStandardSubstitutions)) {
       if (!SubstMerging.tryMergeSubst(*this, *Subst, /*isStandardSubst*/ true)){
         appendOperator("S", *Subst);
       }
diff --git a/lib/Demangling/Demangler.cpp b/lib/Demangling/Demangler.cpp
@@ -975,7 +975,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);          \
   }
diff --git a/lib/Demangling/ManglingUtils.cpp b/lib/Demangling/ManglingUtils.cpp
@@ -66,15 +66,16 @@ std::string Mangle::translateOperator(StringRef Op) {
   return Encoded;
 }
 
-llvm::Optional<StringRef> Mangle::getStandardTypeSubst(StringRef TypeName) {
+llvm::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"
diff --git a/lib/Demangling/Remangler.cpp b/lib/Demangling/Remangler.cpp
@@ -397,7 +397,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;
     }
diff --git a/lib/IRGen/IRGenMangler.cpp b/lib/IRGen/IRGenMangler.cpp
@@ -16,6 +16,7 @@
 #include "swift/AST/IRGenOptions.h"
 #include "swift/AST/ProtocolAssociations.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/Basic/Platform.h"
 #include "swift/Demangling/ManglingMacros.h"
 #include "swift/Demangling/Demangle.h"
 #include "swift/ABI/MetadataValues.h"
@@ -98,7 +99,8 @@ IRGenMangler::withSymbolicReferences(IRGenModule &IGM,
       // manglings already, and the runtime ought to have a lookup table for
       // them. Symbolic referencing would be wasteful.
       if (type->getModuleContext()->hasStandardSubstitutions()
-          && Mangle::getStandardTypeSubst(type->getName().str())) {
+          && Mangle::getStandardTypeSubst(
+               type->getName().str(), AllowConcurrencyStandardSubstitutions)) {
         return false;
       }
       
@@ -146,6 +148,17 @@ SymbolicMangling
 IRGenMangler::mangleTypeForReflection(IRGenModule &IGM,
                                       CanGenericSignature Sig,
                                       CanType Ty) {
+  // If our target predates Swift 5.5, we cannot apply the standard
+  // substitutions for types defined in the Concurrency module.
+  ASTContext &ctx = Ty->getASTContext();
+  llvm::SaveAndRestore<bool> savedConcurrencyStandardSubstitutions(
+      AllowConcurrencyStandardSubstitutions);
+  if (auto runtimeCompatVersion = getSwiftRuntimeCompatibilityVersionForTarget(
+          ctx.LangOpts.Target)) {
+    if (*runtimeCompatVersion < llvm::VersionTuple(5, 5))
+      AllowConcurrencyStandardSubstitutions = false;
+  }
+
   return withSymbolicReferences(IGM, [&]{
     appendType(Ty, Sig);
   });
diff --git a/lib/SIL/Utils/InstructionUtils.cpp b/lib/SIL/Utils/InstructionUtils.cpp
@@ -125,10 +125,9 @@ SILValue swift::stripCastsWithoutMarkDependence(SILValue v) {
       return v;
 
     if (auto *svi = dyn_cast<SingleValueInstruction>(v)) {
-      if (isRCIdentityPreservingCast(svi)
-          || isa<UncheckedTrivialBitCastInst>(v)
-          || isa<BeginAccessInst>(v)
-          || isa<EndCOWMutationInst>(v)) {
+      if (isIdentityPreservingRefCast(svi) ||
+          isa<UncheckedTrivialBitCastInst>(v) || isa<BeginAccessInst>(v) ||
+          isa<EndCOWMutationInst>(v)) {
         v = svi->getOperand(0);
         continue;
       }
@@ -141,10 +140,9 @@ SILValue swift::stripCasts(SILValue v) {
   while (true) {
     v = stripSinglePredecessorArgs(v);
     if (auto *svi = dyn_cast<SingleValueInstruction>(v)) {
-      if (isRCIdentityPreservingCast(svi)
-          || isa<UncheckedTrivialBitCastInst>(v)
-          || isa<MarkDependenceInst>(v)
-          || isa<BeginAccessInst>(v)) {
+      if (isIdentityPreservingRefCast(svi) ||
+          isa<UncheckedTrivialBitCastInst>(v) || isa<MarkDependenceInst>(v) ||
+          isa<BeginAccessInst>(v)) {
         v = cast<SingleValueInstruction>(v)->getOperand(0);
         continue;
       }
diff --git a/lib/SIL/Utils/MemAccessUtils.cpp b/lib/SIL/Utils/MemAccessUtils.cpp
@@ -365,6 +365,12 @@ bool swift::isLetAddress(SILValue address) {
 //                          MARK: FindReferenceRoot
 //===----------------------------------------------------------------------===//
 
+bool swift::isIdentityPreservingRefCast(SingleValueInstruction *svi) {
+  // Ignore both copies and other identity and ownership preserving casts
+  return isa<CopyValueInst>(svi) ||
+         isIdentityAndOwnershipPreservingRefCast(svi);
+}
+
 // On some platforms, casting from a metatype to a reference type dynamically
 // allocates a ref-counted box for the metatype. Naturally that is the place
 // where RC-identity begins. Considering the source of such a casts to be
@@ -374,12 +380,12 @@ bool swift::isLetAddress(SILValue address) {
 // The SILVerifier checks that none of these operations cast a trivial value to
 // a reference except unconditional_checked_cast[_value], which is checked By
 // SILDynamicCastInst::isRCIdentityPreserving().
-bool swift::isRCIdentityPreservingCast(SingleValueInstruction *svi) {
+bool swift::isIdentityAndOwnershipPreservingRefCast(
+    SingleValueInstruction *svi) {
   switch (svi->getKind()) {
   default:
     return false;
-  // Ignore ownership casts
-  case SILInstructionKind::CopyValueInst:
+  // Ignore borrows
   case SILInstructionKind::BeginBorrowInst:
   // Ignore class type casts
   case SILInstructionKind::UpcastInst:
@@ -402,8 +408,12 @@ namespace {
 // Essentially RC identity where the starting point is already a reference.
 class FindReferenceRoot {
   SmallPtrSet<SILPhiArgument *, 4> visitedPhis;
+  bool preserveOwnership;
 
 public:
+  FindReferenceRoot(bool preserveOwnership)
+      : preserveOwnership(preserveOwnership) {}
+
   SILValue findRoot(SILValue ref) && {
     SILValue root = recursiveFindRoot(ref);
     assert(root && "all phi inputs must be reachable");
@@ -414,8 +424,15 @@ class FindReferenceRoot {
   // Return an invalid value for a phi with no resolved inputs.
   SILValue recursiveFindRoot(SILValue ref) {
     while (auto *svi = dyn_cast<SingleValueInstruction>(ref)) {
-      if (!isRCIdentityPreservingCast(svi)) {
-        break;
+      // If preserveOwnership is true, stop at the first owned root
+      if (preserveOwnership) {
+        if (!isIdentityAndOwnershipPreservingRefCast(svi)) {
+          break;
+        }
+      } else {
+        if (!isIdentityPreservingRefCast(svi)) {
+          break;
+        }
       }
       ref = svi->getOperand(0);
     };
@@ -451,7 +468,11 @@ class FindReferenceRoot {
 } // end anonymous namespace
 
 SILValue swift::findReferenceRoot(SILValue ref) {
-  return FindReferenceRoot().findRoot(ref);
+  return FindReferenceRoot(false /*preserveOwnership*/).findRoot(ref);
+}
+
+SILValue swift::findOwnershipReferenceRoot(SILValue ref) {
+  return FindReferenceRoot(true /*preserveOwnership*/).findRoot(ref);
 }
 
 //===----------------------------------------------------------------------===//
@@ -1340,7 +1361,7 @@ AccessPathDefUseTraversal::UseKind
 AccessPathDefUseTraversal::visitSingleValueUser(SingleValueInstruction *svi,
                                                 DFSEntry dfs) {
   if (dfs.isRef()) {
-    if (isRCIdentityPreservingCast(svi)) {
+    if (isIdentityPreservingRefCast(svi)) {
       pushUsers(svi, dfs);
       return IgnoredUse;
     }
diff --git a/lib/SIL/Verifier/LoadBorrowImmutabilityChecker.cpp b/lib/SIL/Verifier/LoadBorrowImmutabilityChecker.cpp
@@ -292,8 +292,8 @@ LoadBorrowImmutabilityAnalysis::LoadBorrowImmutabilityAnalysis(
 // \p address may be an address, pointer, or box type.
 bool LoadBorrowImmutabilityAnalysis::isImmutableInScope(
     LoadBorrowInst *lbi, ArrayRef<Operand *> endBorrowUses,
-    AccessPath accessPath) {
-
+    AccessPathWithBase accessPathWithBase) {
+  auto accessPath = accessPathWithBase.accessPath;
   LinearLifetimeChecker checker(deadEndBlocks);
   auto writes = cache.get(accessPath);
 
@@ -303,12 +303,21 @@ bool LoadBorrowImmutabilityAnalysis::isImmutableInScope(
     accessPath.getStorage().print(llvm::errs());
     return false;
   }
+  auto ownershipRoot = accessPath.getStorage().isReference()
+                           ? findOwnershipReferenceRoot(accessPathWithBase.base)
+                           : SILValue();
   // Then for each write...
   for (auto *op : *writes) {
     // First see if the write is a dead end block. In such a case, just skip it.
     if (deadEndBlocks.isDeadEnd(op->getUser()->getParent())) {
       continue;
     }
+    // A destroy_value will be a definite write only when the destroy is on the
+    // ownershipRoot
+    if (isa<DestroyValueInst>(op->getUser())) {
+      if (op->get() != ownershipRoot)
+        continue;
+    }
     // See if the write is within the load borrow's lifetime. If it isn't, we
     // don't have to worry about it.
     if (!checker.validateLifetime(lbi, endBorrowUses, op)) {
@@ -326,7 +335,9 @@ bool LoadBorrowImmutabilityAnalysis::isImmutableInScope(
 //===----------------------------------------------------------------------===//
 
 bool LoadBorrowImmutabilityAnalysis::isImmutable(LoadBorrowInst *lbi) {
-  AccessPath accessPath = AccessPath::computeInScope(lbi->getOperand());
+  auto accessPathWithBase = AccessPathWithBase::compute(lbi->getOperand());
+  auto accessPath = accessPathWithBase.accessPath;
+
   // Bail on an invalid AccessPath. AccessPath completeness is verified
   // independently--it may be invalid in extraordinary situations. When
   // AccessPath is valid, we know all its uses are recognizable.
@@ -358,15 +369,15 @@ bool LoadBorrowImmutabilityAnalysis::isImmutable(LoadBorrowInst *lbi) {
     //
     // TODO: As a separate analysis, verify that the load_borrow scope is always
     // nested within the begin_access scope (to ensure no aliasing access).
-    return isImmutableInScope(lbi, endBorrowUses, accessPath);
+    return isImmutableInScope(lbi, endBorrowUses, accessPathWithBase);
   }
   case AccessedStorage::Argument: {
     auto *arg =
         cast<SILFunctionArgument>(accessPath.getStorage().getArgument());
     if (arg->hasConvention(SILArgumentConvention::Indirect_In_Guaranteed)) {
       return true;
     }
-    return isImmutableInScope(lbi, endBorrowUses, accessPath);
+    return isImmutableInScope(lbi, endBorrowUses, accessPathWithBase);
   }
   // FIXME: A yielded address could overlap with another in this function.
   case AccessedStorage::Yield:
@@ -376,7 +387,7 @@ bool LoadBorrowImmutabilityAnalysis::isImmutable(LoadBorrowInst *lbi) {
   case AccessedStorage::Tail:
   case AccessedStorage::Global:
   case AccessedStorage::Unidentified:
-    return isImmutableInScope(lbi, endBorrowUses, accessPath);
+    return isImmutableInScope(lbi, endBorrowUses, accessPathWithBase);
   }
   llvm_unreachable("Covered switch isn't covered?!");
 }
diff --git a/lib/SIL/Verifier/VerifierPrivate.h b/lib/SIL/Verifier/VerifierPrivate.h
@@ -41,7 +41,7 @@ class LoadBorrowImmutabilityAnalysis {
 private:
   bool isImmutableInScope(LoadBorrowInst *lbi,
                           ArrayRef<Operand *> endBorrowUses,
-                          AccessPath accessPath);
+                          AccessPathWithBase accessPathWithBase);
 };
 
 } // namespace silverifier
diff --git a/stdlib/private/StdlibUnittest/CMakeLists.txt b/stdlib/private/StdlibUnittest/CMakeLists.txt
@@ -16,9 +16,6 @@ if (SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY)
   list(APPEND swift_stdlib_unittest_link_libraries "swift_Concurrency")
   list(APPEND swift_stdlib_unittest_modules "_Concurrency")
 endif()
-if (SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED)
-  list(APPEND swift_stdlib_unittest_link_libraries "swift_Distributed")
-endif()
 
 add_swift_target_library(swiftStdlibUnittest ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_STDLIB
   # This file should be listed the first.  Module name is inferred from the
diff --git a/stdlib/public/runtime/MetadataLookup.cpp b/stdlib/public/runtime/MetadataLookup.cpp
diff --git a/test/SIL/ownership-verifier/load_borrow_invalidation_test.sil b/test/SIL/ownership-verifier/load_borrow_invalidation_test.sil
diff --git a/utils/swift_build_support/swift_build_support/products/backdeployconcurrency.py b/utils/swift_build_support/swift_build_support/products/backdeployconcurrency.py

Original file line number	Diff line number	Diff line change
`@@ -2973,7 +2973,8 @@ bool ASTMangler::tryAppendStandardSubstitution(const GenericTypeDecl *decl) {`
`2973`	`2973`	`return false;`
`2974`	`2974`
`2975`	`2975`	`if (isa<NominalTypeDecl>(decl)) {`
`2976`		`- if (auto Subst = getStandardTypeSubst(decl->getName().str())) {`
	`2976`	`+ if (auto Subst = getStandardTypeSubst(`
	`2977`	`+ decl->getName().str(), AllowConcurrencyStandardSubstitutions)) {`
`2977`	`2978`	`if (!SubstMerging.tryMergeSubst(this, Subst, /isStandardSubst/ true)){`
`2978`	`2979`	`appendOperator("S", *Subst);`
`2979`	`2980`	`}`
Original file line number	Diff line number	Diff line change
`@@ -975,7 +975,7 @@ NodePointer Demangler::createStandardSubstitution(`
`975`	`975`	`return createSwiftType(Node::Kind::KIND, #TYPENAME); \`
`976`	`976`	`}`
`977`	`977`
`978`		`-#define STANDARD_TYPE_2(KIND, MANGLING, TYPENAME) \`
	`978`	`+#define STANDARD_TYPE_CONCURRENCY(KIND, MANGLING, TYPENAME) \`
`979`	`979`	`if (SecondLevel && Subst == #MANGLING[0]) { \`
`980`	`980`	`return createSwiftType(Node::Kind::KIND, #TYPENAME); \`
`981`	`981`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,15 +66,16 @@ std::string Mangle::translateOperator(StringRef Op) {`
`66`	`66`	`return Encoded;`
`67`	`67`	`}`
`68`	`68`
`69`		`-llvm::Optional<StringRef> Mangle::getStandardTypeSubst(StringRef TypeName) {`
	`69`	`+llvm::Optional<StringRef> Mangle::getStandardTypeSubst(`
	`70`	`+ StringRef TypeName, bool allowConcurrencyManglings) {`
`70`	`71`	`#define STANDARD_TYPE(KIND, MANGLING, TYPENAME) \`
`71`	`72`	`if (TypeName == #TYPENAME) { \`
`72`	`73`	`return StringRef(#MANGLING); \`
`73`	`74`	`}`
`74`	`75`
`75`		`-#define STANDARD_TYPE_2(KIND, MANGLING, TYPENAME) \`
`76`		`- if (TypeName == #TYPENAME) { \`
`77`		`- return StringRef("c" #MANGLING); \`
	`76`	`+#define STANDARD_TYPE_CONCURRENCY(KIND, MANGLING, TYPENAME) \`
	`77`	`+ if (allowConcurrencyManglings && TypeName == #TYPENAME) { \`
	`78`	`+ return StringRef("c" #MANGLING); \`
`78`	`79`	`}`
`79`	`80`
`80`	`81`	`#include "swift/Demangling/StandardTypesMangling.def"`
Original file line number	Diff line number	Diff line change
`@@ -397,7 +397,8 @@ bool Remangler::mangleStandardSubstitution(Node *node) {`
`397`	`397`	`if (node->getChild(1)->getKind() != Node::Kind::Identifier)`
`398`	`398`	`return false;`
`399`	`399`
`400`		`- if (auto Subst = getStandardTypeSubst(node->getChild(1)->getText())) {`
	`400`	`+ if (auto Subst = getStandardTypeSubst(`
	`401`	`+ node->getChild(1)->getText(), /allowConcurrencyManglings=/true)) {`
`401`	`402`	`if (!SubstMerging.tryMergeSubst(this, Subst, /isStandardSubst/ true)) {`
`402`	`403`	`Buffer << 'S' << *Subst;`
`403`	`404`	`}`