Strip concurrency-related types from mangled name of @_predatesConcurrency decls

This allows some APIs to evolve toward supporting concurrency without
breaking their ABI.

Author: DougGregor

include/swift/AST/ASTMangler.h

@@ -67,6 +67,9 @@ class ASTMangler : public Mangler {
   /// If enabled, marker protocols can be encoded in the mangled name.
   bool AllowMarkerProtocols = true;
 
+  /// Whether the mangling predates concurrency, and therefore shouldn't
+  bool PredatesConcurrency = false;
+
 public:
   using SymbolicReferent = llvm::PointerUnion<const NominalTypeDecl *,
                                               const OpaqueTypeDecl *>;

include/swift/AST/Types.h

@@ -1189,6 +1189,15 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// types.
   Type lookThroughAllOptionalTypes(SmallVectorImpl<Type> &optionals);
 
+  /// Remove concurrency-related types and constraints from the given
+  /// type
+  ///
+  /// \param recurse Whether to recurse into function types.
+  ///
+  /// \param dropGlobalActor Whether to drop a global actor from a function
+  /// type.
+  Type stripConcurrency(bool recurse, bool dropGlobalActor);
+
   /// Whether this is the AnyObject type.
   bool isAnyObject();
 

lib/AST/ASTDumper.cpp

@@ -3803,6 +3803,10 @@ namespace {
       printFlag(T->isAsync(), "async");
       printFlag(T->isThrowing(), "throws");
 
+      if (Type globalActor = T->getGlobalActor()) {
+        printField("global_actor", globalActor.getString());
+      }
+
       OS << "\n";
       Indent += 2;
       // [TODO: Improve-Clang-type-printing]
@@ -3815,10 +3819,6 @@ namespace {
         printField("clang_type", os.str());
       }
 
-      if (Type globalActor = T->getGlobalActor()) {
-        printField("global_actor", globalActor.getString());
-      }
-
       printAnyFunctionParams(T->getParams(), "input");
       Indent -=2;
       printRec("output", T->getResult());

lib/AST/ASTMangler.cpp

@@ -2969,6 +2969,13 @@ CanType ASTMangler::getDeclTypeForMangling(
 
   Type ty = decl->getInterfaceType()->getReferenceStorageReferent();
 
+  // If this declaration predates concurrency, adjust its type to not
+  // contain type features that were not available pre-concurrency. This
+  // cannot alter the ABI in any way.
+  if (decl->predatesConcurrency()) {
+    ty = ty->stripConcurrency(/*recurse=*/true, /*dropGlobalActor=*/true);
+  }
+
   auto canTy = ty->getCanonicalType();
 
   if (auto gft = dyn_cast<GenericFunctionType>(canTy)) {

lib/AST/Type.cpp

@@ -755,6 +755,94 @@ Type TypeBase::lookThroughAllOptionalTypes(SmallVectorImpl<Type> &optionals){
   return type;
 }
 
+Type TypeBase::stripConcurrency(bool recurse, bool dropGlobalActor) {
+  // Look through optionals.
+  if (Type optionalObject = getOptionalObjectType()) {
+    Type newOptionalObject =
+        optionalObject->stripConcurrency(recurse, dropGlobalActor);
+    if (optionalObject->isEqual(newOptionalObject))
+      return Type(this);
+
+    return OptionalType::get(newOptionalObject);
+  }
+
+  // Function types.
+  if (auto fnType = getAs<AnyFunctionType>()) {
+    // Strip off Sendable and (possibly) the global actor.
+    ASTExtInfo extInfo =
+        fnType->hasExtInfo() ? fnType->getExtInfo() : ASTExtInfo();
+    extInfo = extInfo.withConcurrent(false);
+    if (dropGlobalActor)
+      extInfo = extInfo.withGlobalActor(Type());
+
+    ArrayRef<AnyFunctionType::Param> params = fnType->getParams();
+    Type resultType = fnType->getResult();
+
+    SmallVector<AnyFunctionType::Param, 4> newParams;
+    if (recurse) {
+      for (unsigned paramIdx : indices(params)) {
+        const auto &param = params[paramIdx];
+        Type newParamType = param.getPlainType()->stripConcurrency(
+            recurse, dropGlobalActor);
+
+        if (!newParams.empty()) {
+          newParams.push_back(param.withType(newParamType));
+          continue;
+        }
+
+        if (newParamType->isEqual(param.getPlainType()))
+          continue;
+
+        newParams.append(params.begin(), params.begin() + paramIdx);
+        newParams.push_back(param.withType(newParamType));
+      }
+
+      if (!newParams.empty())
+        params = newParams;
+
+      resultType = resultType->stripConcurrency(recurse, dropGlobalActor);
+    }
+
+    // Drop Sendable requirements.
+    GenericSignature genericSig;
+    if (auto genericFnType = dyn_cast<GenericFunctionType>(fnType)) {
+      auto requirements = genericFnType->getRequirements();
+      SmallVector<Requirement, 4> newRequirements;
+      for (unsigned reqIdx : indices(requirements)) {
+        // If it's a Sendable requirement, skip it.
+        const auto &req = requirements[reqIdx];
+        if (req.getKind() == RequirementKind::Conformance &&
+            req.getSecondType()->castTo<ProtocolType>()->getDecl()
+              ->isSpecificProtocol(KnownProtocolKind::Sendable))
+          continue;
+
+        newRequirements.push_back(req);
+      }
+
+      if (newRequirements.size() == requirements.size()) {
+        genericSig = genericFnType->getGenericSignature();
+      } else {
+        genericSig = GenericSignature::get(
+            genericFnType->getGenericParams(), newRequirements);
+      }
+    }
+
+    Type newFnType;
+    if (genericSig) {
+      newFnType = GenericFunctionType::get(
+          genericSig, params, resultType, extInfo);
+    } else {
+      newFnType = FunctionType::get(params, resultType, extInfo);
+    }
+    if (newFnType->isEqual(this))
+      return Type(this);
+
+    return newFnType;
+  }
+
+  return Type(this);
+}
+
 bool TypeBase::isAnyObject() {
   auto canTy = getCanonicalType();
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -4037,34 +4037,6 @@ static Type applyUnsafeConcurrencyToParameterType(
                                .withGlobalActor(globalActor));
 }
 
-/// Strip concurrency from the given type.
-static Type stripConcurrencyFromType(Type type, bool dropGlobalActor) {
-  // Look through optionals.
-  if (Type optionalObject = type->getOptionalObjectType()) {
-    Type newOptionalObject =
-        stripConcurrencyFromType(optionalObject, dropGlobalActor);
-    if (optionalObject->isEqual(newOptionalObject))
-      return type;
-
-    return OptionalType::get(newOptionalObject);
-  }
-
-  // For function types, strip off Sendable and possibly the global actor.
-  if (auto fnType = type->getAs<FunctionType>()) {
-    auto extInfo = fnType->getExtInfo().withConcurrent(false);
-    if (dropGlobalActor)
-      extInfo = extInfo.withGlobalActor(Type());
-    auto newFnType = FunctionType::get(
-        fnType->getParams(), fnType->getResult(), extInfo);
-    if (newFnType->isEqual(type))
-      return type;
-
-    return newFnType;
-  }
-
-  return type;
-}
-
 /// Determine whether the given name is that of a DispatchQueue operation that
 /// takes a closure to be executed on the queue.
 bool swift::isDispatchQueueOperationName(StringRef name) {
@@ -4112,7 +4084,7 @@ Type swift::adjustVarTypeForConcurrency(
     isLValue = true;
   }
 
-  type = stripConcurrencyFromType(type, /*dropGlobalActor=*/true);
+  type = type->stripConcurrency(/*recurse=*/false, /*dropGlobalActor=*/true);
 
   if (isLValue)
     type = LValueType::get(type);
@@ -4164,8 +4136,8 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
       newParamType = applyUnsafeConcurrencyToParameterType(
         param.getPlainType(), addSendable, addMainActor);
     } else if (stripConcurrency) {
-      newParamType = stripConcurrencyFromType(
-          param.getPlainType(), numApplies == 0);
+      newParamType = param.getPlainType()->stripConcurrency(
+          /*recurse=*/false, /*dropGlobalActor=*/numApplies == 0);
     }
 
     if (!newParamType || newParamType->isEqual(param.getPlainType())) {
@@ -4189,8 +4161,8 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
   // Compute the new result type.
   Type newResultType = fnType->getResult();
   if (stripConcurrency) {
-    newResultType = stripConcurrencyFromType(
-        newResultType, /*dropGlobalActor=*/true);
+    newResultType = newResultType->stripConcurrency(
+        /*recurse=*/false, /*dropGlobalActor=*/true);
 
     if (!newResultType->isEqual(fnType->getResult()) && newTypeParams.empty()) {
       newTypeParams.append(typeParams.begin(), typeParams.end());

test/SILGen/mangling_predates_concurrency.swift

@@ -0,0 +1,8 @@
+// RUN: %target-swift-emit-silgen %s | %FileCheck %s
+
+
+// CHECK: sil [ossa] @$s29mangling_predates_concurrency16excitingFunction5value4bodyyycx_yycSgtlF : $@convention(thin) <T where T : Sendable> (@in_guaranteed T, @guaranteed Optional<@Sendable @callee_guaranteed () -> ()>) -> @owned @callee_guaranteed () -> ()
+@_predatesConcurrency
+public func excitingFunction<T: Sendable>(value: T, body: (@Sendable () -> Void)?) -> (@MainActor () -> Void) {
+  { }
+}