Merge pull request #40271 from DougGregor/predates-concurrency-abi-c

Author: swift-ci

include/swift/AST/ASTMangler.h

@@ -67,6 +67,11 @@ 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
+  /// include concurrency features such as global actors or @Sendable
+  /// function types.
+  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/Decl.cpp

@@ -46,6 +46,7 @@
 #include "swift/AST/TypeLoc.h"
 #include "swift/AST/SwiftNameTranslation.h"
 #include "swift/Basic/Defer.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/Parse/Lexer.h" // FIXME: Bad dependency
 #include "clang/Lex/MacroInfo.h"
 #include "llvm/ADT/SmallPtrSet.h"
@@ -719,7 +720,14 @@ Optional<CustomAttrNominalPair> Decl::getGlobalActorAttr() const {
 }
 
 bool Decl::predatesConcurrency() const {
-  return getAttrs().hasAttribute<PredatesConcurrencyAttr>();
+  if (getAttrs().hasAttribute<PredatesConcurrencyAttr>())
+    return true;
+
+  // Imported C declarations always predate concurrency.
+  if (isa<ClangModuleUnit>(getDeclContext()->getModuleScopeContext()))
+    return true;
+
+  return false;
 }
 
 

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/ClangImporter/ImportDecl.cpp

@@ -8392,17 +8392,13 @@ SourceFile &ClangImporter::Implementation::getClangSwiftAttrSourceFile(
   return *sourceFile;
 }
 
-Optional<bool> swift::importer::isMainActorAttr(
-    ASTContext &ctx, const clang::SwiftAttrAttr *swiftAttr) {
+bool swift::importer::isMainActorAttr(const clang::SwiftAttrAttr *swiftAttr) {
   if (swiftAttr->getAttribute() == "@MainActor" ||
-      swiftAttr->getAttribute() == "@MainActor(unsafe)" ||
       swiftAttr->getAttribute() == "@UIActor") {
-    bool isUnsafe = swiftAttr->getAttribute() == "@MainActor(unsafe)" ||
-        !ctx.LangOpts.isSwiftVersionAtLeast(6);
-    return isUnsafe;
+    return true;
   }
 
-  return None;
+  return false;
 }
 
 void
@@ -8430,9 +8426,7 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
   for (auto swiftAttr : ClangDecl->specific_attrs<clang::SwiftAttrAttr>()) {
     // FIXME: Hard-code @MainActor and @UIActor, because we don't have a
     // point at which to do name lookup for imported entities.
-    if (auto isMainActor = isMainActorAttr(SwiftContext, swiftAttr)) {
-      bool isUnsafe = *isMainActor;
-
+    if (isMainActorAttr(swiftAttr)) {
       if (SeenMainActorAttr) {
         // Cannot add main actor annotation twice. We'll keep the first
         // one and raise a warning about the duplicate.
@@ -8446,7 +8440,6 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
       if (Type mainActorType = SwiftContext.getMainActorType()) {
         auto typeExpr = TypeExpr::createImplicit(mainActorType, SwiftContext);
         auto attr = CustomAttr::create(SwiftContext, SourceLoc(), typeExpr);
-        attr->setArgIsUnsafe(isUnsafe);
         MappedDecl->getAttrs().add(attr);
         SeenMainActorAttr = swiftAttr;
       }

lib/ClangImporter/ImportType.cpp

@@ -1726,7 +1726,7 @@ Type ClangImporter::Implementation::applyParamAttributes(
       continue;
 
     // Map the main-actor attribute.
-    if (isMainActorAttr(SwiftContext, swiftAttr)) {
+    if (isMainActorAttr(swiftAttr)) {
       if (Type mainActor = SwiftContext.getMainActorType()) {
         type = applyToFunctionType(type, [&](ASTExtInfo extInfo) {
           return extInfo.withGlobalActor(mainActor);

lib/ClangImporter/ImporterImpl.h

@@ -1663,11 +1663,7 @@ class SwiftNameLookupExtension : public clang::ModuleFileExtension {
 
 /// Determines whether the given swift_attr attribute describes the main
 /// actor.
-///
-/// \returns None if this is not a main-actor attribute, and a Boolean
-/// indicating whether (unsafe) was provided in the attribute otherwise.
-Optional<bool> isMainActorAttr(
-    ASTContext &ctx, const clang::SwiftAttrAttr *swiftAttr);
+bool isMainActorAttr(const clang::SwiftAttrAttr *swiftAttr);
 
 }
 }

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());