Merge pull request swiftlang#40677 from beccadax/sendable-to-the-whole-block

[ClangImporter] Make completion handlers Sendable

Author: beccadax

lib/AST/ASTPrinter.cpp

@@ -5428,7 +5428,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
 
     if (!Options.excludeAttrKind(TAK_Sendable) &&
         info.isSendable()) {
-      Printer << "@Sendable ";
+      Printer.printSimpleAttr("@Sendable") << " ";
     }
 
     SmallString<64> buf;

lib/ClangImporter/ImportDecl.cpp

@@ -2796,6 +2796,15 @@ namespace {
                                       SourceLoc(), Name,
                                       Loc,
                                       /*genericparams*/nullptr, DC);
+
+      // If the typedef is marked with @Sendable and not @_nonSendable, make
+      // any function type in it Sendable.
+      auto sendability = Result->getAttrs().getEffectiveSendableAttr();
+      if (isa_and_nonnull<SendableAttr>(sendability))
+        SwiftType = applyToFunctionType(SwiftType, [](ASTExtInfo info) {
+          return info.withConcurrent();
+        });
+
       Result->setUnderlyingType(SwiftType);
 
       // Make Objective-C's 'id' unavailable.

lib/ClangImporter/ImportName.cpp

@@ -2270,6 +2270,17 @@ ImportedName NameImporter::importName(const clang::NamedDecl *decl,
   }
   ++ImportNameNumCacheMisses;
   auto res = importNameImpl(decl, version, givenName);
+
+  // Add information about the async version of the name to the non-async
+  // version of the name.
+  if (!version.supportsConcurrency()) {
+    if (auto importedAsyncName = importName(decl, version.withConcurrency(true),
+                                            givenName)) {
+      res.info.hasAsyncAlternateInfo = importedAsyncName.info.hasAsyncInfo;
+      res.info.asyncInfo = importedAsyncName.info.asyncInfo;
+    }
+  }
+
   if (!givenName)
     importNameCache[key] = res;
   return res;

lib/ClangImporter/ImportName.h

@@ -226,11 +226,14 @@ class ImportedName {
 
     unsigned hasAsyncInfo : 1;
 
+    unsigned hasAsyncAlternateInfo: 1;
+
     Info()
         : errorInfo(), selfIndex(), initKind(CtorInitializerKind::Designated),
           accessorKind(ImportedAccessorKind::None), hasCustomName(false),
           droppedVariadic(false), importAsMember(false), hasSelfIndex(false),
-          hasErrorInfo(false), hasAsyncInfo(false) {}
+          hasErrorInfo(false), hasAsyncInfo(false),
+          hasAsyncAlternateInfo(false) {}
   } info;
 
 public:
@@ -267,8 +270,27 @@ class ImportedName {
   /// For names that map Objective-C methods with completion handlers into
   /// async Swift methods, describes how the mapping is performed.
   Optional<ForeignAsyncConvention::Info> getAsyncInfo() const {
-    if (info.hasAsyncInfo)
+    if (info.hasAsyncInfo) {
+      assert(!info.hasAsyncAlternateInfo
+             && "both regular and alternate async info?");
+      return info.asyncInfo;
+    }
+    return None;
+  }
+
+  /// For names with a variant that maps Objective-C methods with completion
+  /// handlers into async Swift methods, describes how the mapping is performed.
+  ///
+  /// That is, if the method imports as both an async method and a completion
+  /// handler method, this value is set on the completion handler method's name
+  /// and gives you the contents of \c getAsyncInfo() on the async method's
+  /// name. It is not set on the async method's name, and it is not set if a
+  /// non-async method doesn't have an async equivalent.
+  Optional<ForeignAsyncConvention::Info> getAsyncAlternateInfo() const {
+    if (info.hasAsyncAlternateInfo) {
+      assert(!info.hasAsyncInfo && "both regular and alternate async info?");
       return info.asyncInfo;
+    }
     return None;
   }
 

lib/ClangImporter/ImportType.cpp

@@ -1754,63 +1754,58 @@ ImportedType ClangImporter::Implementation::importPropertyType(
                     Bridgeability::Full, optionality);
 }
 
-/// Apply an attribute to a function type.
-static Type applyToFunctionType(
-    Type type, llvm::function_ref<ASTExtInfo(ASTExtInfo)> transform) {
-  // Recurse into optional types.
-  if (Type objectType = type->getOptionalObjectType()) {
-    return OptionalType::get(applyToFunctionType(objectType, transform));
-  }
-
-  // Apply @noescape to function types.
-  if (auto funcType = type->getAs<FunctionType>()) {
-    return FunctionType::get(funcType->getParams(), funcType->getResult(),
-                             transform(funcType->getExtInfo()));
-  }
-
-  return type;
-}
-
 Type ClangImporter::Implementation::applyParamAttributes(
-    const clang::ParmVarDecl *param, Type type) {
-  if (!param->hasAttrs())
-    return type;
+    const clang::ParmVarDecl *param, Type type, bool sendableByDefault) {
+  bool sendableRequested = sendableByDefault;
+  bool sendableDisqualified = false;
+
+  if (param->hasAttrs()) {
+    for (auto attr : param->getAttrs()) {
+      // Map __attribute__((noescape)) to @noescape.
+      if (isa<clang::NoEscapeAttr>(attr)) {
+        type = applyToFunctionType(type, [](ASTExtInfo extInfo) {
+          return extInfo.withNoEscape();
+        });
 
-  for (auto attr : param->getAttrs()) {
-    // Map __attribute__((noescape)) to @noescape.
-    if (isa<clang::NoEscapeAttr>(attr)) {
-      type = applyToFunctionType(type, [](ASTExtInfo extInfo) {
-        return extInfo.withNoEscape();
-      });
+        continue;
+      }
 
-      continue;
-    }
+      auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr);
+      if (!swiftAttr)
+        continue;
 
-    auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr);
-    if (!swiftAttr)
-      continue;
+      // Map the main-actor attribute.
+      if (isMainActorAttr(swiftAttr)) {
+        if (Type mainActor = SwiftContext.getMainActorType()) {
+          type = applyToFunctionType(type, [&](ASTExtInfo extInfo) {
+            return extInfo.withGlobalActor(mainActor);
+          });
+          sendableDisqualified = true;
+        }
 
-    // Map the main-actor attribute.
-    if (isMainActorAttr(swiftAttr)) {
-      if (Type mainActor = SwiftContext.getMainActorType()) {
-        type = applyToFunctionType(type, [&](ASTExtInfo extInfo) {
-          return extInfo.withGlobalActor(mainActor);
-        });
+        continue;
       }
 
-      continue;
-    }
-
-    // Map @Sendable.
-    if (swiftAttr->getAttribute() == "@Sendable") {
-      type = applyToFunctionType(type, [](ASTExtInfo extInfo) {
-        return extInfo.withConcurrent();
-      });
+      // Map @Sendable.
+      if (swiftAttr->getAttribute() == "@Sendable") {
+        sendableRequested = true;
+        continue;
+      }
 
-      continue;
+      // Map @_nonSendable.
+      if (swiftAttr->getAttribute() == "@_nonSendable") {
+        sendableDisqualified = true;
+        continue;
+      }
     }
   }
 
+  if (!sendableDisqualified && sendableRequested) {
+    type = applyToFunctionType(type, [](ASTExtInfo extInfo) {
+      return extInfo.withConcurrent();
+    });
+  }
+
   return type;
 }
 
@@ -2015,7 +2010,7 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
 
     // Apply attributes to the type.
     swiftParamTy = applyParamAttributes(
-        param, swiftParamTy);
+        param, swiftParamTy, /*sendableByDefault=*/false);
 
     // Figure out the name for this parameter.
     Identifier bodyName = importFullName(param, CurrentVersion)
@@ -2401,6 +2396,10 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
   Optional<ForeignErrorConvention::Info> errorInfo =
       importedName.getErrorInfo();
   auto asyncInfo = importedName.getAsyncInfo();
+  bool isAsync = asyncInfo.hasValue();
+  if (!isAsync)
+    asyncInfo = importedName.getAsyncAlternateInfo();
+
   OptionalTypeKind OptionalityOfReturn;
   if (clangDecl->hasAttr<clang::ReturnsNonNullAttr>()) {
     OptionalityOfReturn = OTK_None;
@@ -2547,7 +2546,7 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
       // Figure out if this is a completion handler parameter whose error
       // parameter is used to indicate throwing.
       Optional<unsigned> completionHandlerErrorParamIndex;
-      if (paramIsCompletionHandler) {
+      if (isAsync && paramIsCompletionHandler) {
         completionHandlerErrorParamIndex =
             asyncInfo->completionHandlerErrorParamIndex();
       }
@@ -2592,7 +2591,7 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
 
     // If this is a completion handler, figure out it's effect on the result
     // type but don't build it into the parameter type.
-    if (paramIsCompletionHandler) {
+    if (isAsync && paramIsCompletionHandler) {
       if (Type replacedSwiftResultTy =
               decomposeCompletionHandlerType(swiftParamTy, *asyncInfo)) {
         swiftResultTy = replacedSwiftResultTy;
@@ -2611,7 +2610,8 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
     }
 
     // Apply Clang attributes to the parameter type.
-    swiftParamTy = applyParamAttributes(param, swiftParamTy);
+    swiftParamTy = applyParamAttributes(param, swiftParamTy,
+                  /*sendableByDefault=*/paramIsCompletionHandler);
 
     // Figure out the name for this parameter.
     Identifier bodyName = importFullName(param, CurrentVersion)
@@ -2686,7 +2686,7 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
     swiftResultTy = SwiftContext.getNeverType();
   }
 
-  if (asyncInfo) {
+  if (isAsync) {
     asyncConvention = ForeignAsyncConvention(
         completionHandlerType, asyncInfo->completionHandlerParamIndex(),
         asyncInfo->completionHandlerErrorParamIndex(),

lib/ClangImporter/ImporterImpl.h

@@ -937,7 +937,8 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   void importAttributes(const clang::NamedDecl *ClangDecl, Decl *MappedDecl,
                         const clang::ObjCContainerDecl *NewContext = nullptr);
 
-  Type applyParamAttributes(const clang::ParmVarDecl *param, Type type);
+  Type applyParamAttributes(const clang::ParmVarDecl *param, Type type,
+                            bool sendableByDefault);
 
   /// If we already imported a given decl, return the corresponding Swift decl.
   /// Otherwise, return nullptr.
@@ -1752,6 +1753,25 @@ class SwiftNameLookupExtension : public clang::ModuleFileExtension {
 /// actor.
 bool isMainActorAttr(const clang::SwiftAttrAttr *swiftAttr);
 
+/// Apply an attribute to a function type.
+static inline Type applyToFunctionType(
+    Type type, llvm::function_ref<ASTExtInfo(ASTExtInfo)> transform) {
+  // Recurse into optional types.
+  if (Type objectType = type->getOptionalObjectType()) {
+    return OptionalType::get(applyToFunctionType(objectType, transform));
+  }
+
+  // Apply transform to function types.
+  if (auto funcType = type->getAs<FunctionType>()) {
+    auto newExtInfo = transform(funcType->getExtInfo());
+    if (!newExtInfo.isEqualTo(funcType->getExtInfo(), /*useClangTypes=*/true))
+      return FunctionType::get(funcType->getParams(), funcType->getResult(),
+                               newExtInfo);
+  }
+
+  return type;
+}
+
 }
 }
 

lib/Sema/TypeCheckProtocol.cpp

@@ -140,15 +140,31 @@ getTypesToCompare(ValueDecl *reqt, Type reqtType, bool reqtTypeIsIUO,
                   Type witnessType, bool witnessTypeIsIUO,
                   VarianceKind variance) {
   // If the witness type is noescape but the requirement type is not,
-  // adjust the witness type to be escaping. This permits a limited form of
-  // covariance.
-  bool reqNoescapeToEscaping = false;
-  (void)adjustInferredAssociatedType(reqtType, reqNoescapeToEscaping);
-  bool witnessNoescapeToEscaping = false;
-  Type adjustedWitnessType =
-    adjustInferredAssociatedType(witnessType, witnessNoescapeToEscaping);
-  if (witnessNoescapeToEscaping && !reqNoescapeToEscaping)
-    witnessType = adjustedWitnessType;
+  // adjust the witness type to be escaping; likewisse for sendability. This
+  // permits a limited form of covariance.
+  auto applyAdjustment = [&](TypeAdjustment adjustment) {
+    // Sometimes the witness has a function type, but the requirement has
+    // something else (a dependent type we need to infer, in the most relevant
+    // case). In that situation, should we behave as though the requirement type
+    // *did* need the adjustment, or as though it *did not*?
+    //
+    // For noescape, we want to behave as though it was necessary because any
+    // function type not in a parameter is, more or less, implicitly @escaping.
+    // For Sendable, we want to behave as though it was not necessary because
+    // function types that aren't in a parameter can be Sendable or not.
+    // FIXME: Should we check for a Sendable bound on the requirement type?
+    bool inRequirement = (adjustment != TypeAdjustment::NoescapeToEscaping);
+    (void)adjustInferredAssociatedType(adjustment, reqtType, inRequirement);
+
+    bool inWitness = false;
+    Type adjustedWitnessType =
+      adjustInferredAssociatedType(adjustment, witnessType, inWitness);
+    if (inWitness && !inRequirement)
+      witnessType = adjustedWitnessType;
+  };
+
+  applyAdjustment(TypeAdjustment::NoescapeToEscaping);
+  applyAdjustment(TypeAdjustment::NonsendableToSendable);
 
   // For @objc protocols, deal with differences in the optionality.
   // FIXME: It probably makes sense to extend this to non-@objc

lib/Sema/TypeCheckProtocol.h

@@ -1136,12 +1136,19 @@ matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
 AssociatedTypeDecl *getReferencedAssocTypeOfProtocol(Type type,
                                                      ProtocolDecl *proto);
 
+enum class TypeAdjustment : uint8_t {
+  NoescapeToEscaping, NonsendableToSendable
+};
+
 /// Perform any necessary adjustments to the inferred associated type to
 /// make it suitable for later use.
 ///
-/// \param noescapeToEscaping Will be set \c true if this operation performed
-/// the noescape-to-escaping adjustment.
-Type adjustInferredAssociatedType(Type type, bool &noescapeToEscaping);
+/// \param performed Will be set \c true if this operation performed
+/// the adjustment, or \c false if the operation found a type that the
+/// adjustment could have applied to but did not actually need to adjust it.
+/// Unchanged otherwise.
+Type adjustInferredAssociatedType(TypeAdjustment adjustment, Type type,
+                                  bool &performed);
 
 /// Find the @objc requirement that are witnessed by the given
 /// declaration.