[Concurrency] Import "did" delegate methods as @asyncHandler.

include/swift/AST/Decl.h

@@ -5948,6 +5948,10 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Returns true if the function is an @asyncHandler.
   bool isAsyncHandler() const;
 
+  /// Returns true if the function if the signature matches the form of an
+  /// @asyncHandler.
+  bool canBeAsyncHandler() const;
+
   /// Returns true if the function body throws.
   bool hasThrows() const { return Bits.AbstractFunctionDecl.Throws; }
 

include/swift/AST/TypeCheckRequests.h

@@ -797,6 +797,25 @@ class IsAsyncHandlerRequest :
   bool isCached() const { return true; }
 };
 
+/// Determine whether the given function can be an @asyncHandler, without
+/// producing any diagnostics.
+class CanBeAsyncHandlerRequest :
+    public SimpleRequest<CanBeAsyncHandlerRequest,
+                         bool(FuncDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, FuncDecl *func) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 /// Determine whether the given class is an actor.
 class IsActorRequest :
     public SimpleRequest<IsActorRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -83,6 +83,8 @@ SWIFT_REQUEST(TypeChecker, FunctionBuilderTypeRequest, Type(ValueDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsAsyncHandlerRequest, bool(FuncDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, CanBeAsyncHandlerRequest, bool(FuncDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsActorRequest, bool(ClassDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ActorIsolationRequest,

lib/AST/Decl.cpp

@@ -6791,6 +6791,17 @@ bool AbstractFunctionDecl::isAsyncHandler() const {
                            false);
 }
 
+bool AbstractFunctionDecl::canBeAsyncHandler() const {
+  auto func = dyn_cast<FuncDecl>(this);
+  if (!func)
+    return false;
+
+  auto mutableFunc = const_cast<FuncDecl *>(func);
+  return evaluateOrDefault(getASTContext().evaluator,
+                           CanBeAsyncHandlerRequest{mutableFunc},
+                           false);
+}
+
 BraceStmt *AbstractFunctionDecl::getBody(bool canSynthesize) const {
   if ((getBodyKind() == BodyKind::Synthesize ||
        getBodyKind() == BodyKind::Unparsed) &&

lib/ClangImporter/ImportDecl.cpp

@@ -40,6 +40,7 @@
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/PrettyStackTrace.h"
 #include "swift/Basic/Statistic.h"
+#include "swift/Basic/StringExtras.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/Config.h"
 #include "swift/Parse/Lexer.h"
@@ -7575,6 +7576,46 @@ bool importer::isSpecialUIKitStructZeroProperty(const clang::NamedDecl *decl) {
   return ident->isStr("UIEdgeInsetsZero") || ident->isStr("UIOffsetZero");
 }
 
+/// Determine whether any of the parameters to the given function is of an
+/// unsafe pointer type.
+static bool hasAnyUnsafePointerParameters(FuncDecl *func) {
+  for (auto param : *func->getParameters()) {
+    Type paramType =
+        param->toFunctionParam().getPlainType()->lookThroughAllOptionalTypes();
+    if (paramType->getAnyPointerElementType()) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/// Determine whether the given Objective-C method is likely to be an
+/// asynchronous handler based on its name.
+static bool isObjCMethodLikelyAsyncHandler(
+    const clang::ObjCMethodDecl *method) {
+  auto selector = method->getSelector();
+
+  for (unsigned argIdx : range(std::max(selector.getNumArgs(), 1u))) {
+    auto selectorPiece = selector.getNameForSlot(argIdx);
+    // For the first selector piece, look for the word "did" anywhere.
+    if (argIdx == 0) {
+      for (auto word : camel_case::getWords(selectorPiece)) {
+        if (word == "did" || word == "Did")
+          return true;
+      }
+
+      continue;
+    }
+
+    // Otherwise, check whether any subsequent selector piece starts with "did".
+    if (camel_case::getFirstWord(selectorPiece) == "did")
+      return true;
+  }
+
+  return false;
+}
+
 /// Import Clang attributes as Swift attributes.
 void ClangImporter::Implementation::importAttributes(
     const clang::NamedDecl *ClangDecl,
@@ -7813,6 +7854,24 @@ void ClangImporter::Implementation::importAttributes(
   if (ClangDecl->hasAttr<clang::PureAttr>()) {
     MappedDecl->getAttrs().add(new (C) EffectsAttr(EffectsKind::ReadOnly));
   }
+
+  // Infer @asyncHandler on imported protocol methods that meet the semantic
+  // requirements.
+  if (SwiftContext.LangOpts.EnableExperimentalConcurrency) {
+    if (auto func = dyn_cast<FuncDecl>(MappedDecl)) {
+      if (auto proto = dyn_cast<ProtocolDecl>(func->getDeclContext())) {
+        if (proto->isObjC() && isa<clang::ObjCMethodDecl>(ClangDecl) &&
+            func->isInstanceMember() && !isa<AccessorDecl>(func) &&
+            isObjCMethodLikelyAsyncHandler(
+                cast<clang::ObjCMethodDecl>(ClangDecl)) &&
+            func->canBeAsyncHandler() &&
+            !hasAnyUnsafePointerParameters(func)) {
+          MappedDecl->getAttrs().add(
+              new (C) AsyncHandlerAttr(/*IsImplicit=*/false));
+        }
+      }
+    }
+  }
 }
 
 Decl *

lib/Sema/TypeCheckConcurrency.cpp

@@ -22,7 +22,14 @@
 
 using namespace swift;
 
-bool swift::checkAsyncHandler(FuncDecl *func, bool diagnose) {
+/// Check whether the @asyncHandler attribute can be applied to the given
+/// function declaration.
+///
+/// \param diagnose Whether to emit a diagnostic when a problem is encountered.
+///
+/// \returns \c true if there was a problem with adding the attribute, \c false
+/// otherwise.
+static bool checkAsyncHandler(FuncDecl *func, bool diagnose) {
   if (!func->getResultInterfaceType()->isVoid()) {
     if (diagnose) {
       func->diagnose(diag::asynchandler_returns_value)
@@ -78,7 +85,7 @@ bool swift::checkAsyncHandler(FuncDecl *func, bool diagnose) {
 void swift::addAsyncNotes(FuncDecl *func) {
   func->diagnose(diag::note_add_async_to_function, func->getName());
 
-  if (!checkAsyncHandler(func, /*diagnose=*/false)) {
+  if (func->canBeAsyncHandler()) {
     func->diagnose(
             diag::note_add_asynchandler_to_function, func->getName())
         .fixItInsert(func->getAttributeInsertionLoc(false), "@asyncHandler ");
@@ -108,7 +115,7 @@ bool IsAsyncHandlerRequest::evaluate(
     return false;
 
   // Is it possible to infer @asyncHandler for this function at all?
-  if (checkAsyncHandler(func, /*diagnose=*/false))
+  if (!func->canBeAsyncHandler())
     return false;
 
   // Add an implicit @asyncHandler attribute and return true. We're done.
@@ -157,6 +164,11 @@ bool IsAsyncHandlerRequest::evaluate(
   return false;
 }
 
+bool CanBeAsyncHandlerRequest::evaluate(
+    Evaluator &evaluator, FuncDecl *func) const {
+  return !checkAsyncHandler(func, /*diagnose=*/false);
+}
+
 bool IsActorRequest::evaluate(
     Evaluator &evaluator, ClassDecl *classDecl) const {
   // If concurrency is not enabled, we don't have actors.

lib/Sema/TypeCheckConcurrency.h

@@ -26,15 +26,6 @@ class Expr;
 class FuncDecl;
 class ValueDecl;
 
-/// Check whether the @asyncHandler attribute can be applied to the given
-/// function declaration.
-///
-/// \param diagnose Whether to emit a diagnostic when a problem is encountered.
-///
-/// \returns \c true if there was a problem with adding the attribute, \c false
-/// otherwise.
-bool checkAsyncHandler(FuncDecl *func, bool diagnose);
-
 /// Add notes suggesting the addition of 'async' or '@asyncHandler', as
 /// appropriate, to a diagnostic for a function that isn't an async context.
 void addAsyncNotes(FuncDecl *func);

lib/Sema/TypeCheckProtocol.cpp

@@ -2458,7 +2458,7 @@ diagnoseMatch(ModuleDecl *module, NormalProtocolConformance *conformance,
     bool canBeAsyncHandler = false;
     if (auto witnessFunc = dyn_cast<FuncDecl>(match.Witness)) {
       canBeAsyncHandler = !witnessFunc->isAsyncHandler() &&
-          !checkAsyncHandler(witnessFunc, /*diagnose=*/false);
+          witnessFunc->canBeAsyncHandler();
     }
     auto diag = match.Witness->diagnose(
         canBeAsyncHandler ? diag::actor_isolated_witness_could_be_async_handler

test/IDE/print_clang_objc_async.swift

@@ -18,3 +18,11 @@
 // CHECK-DAG:     func findAnswerFailingly() async throws -> String?
 // CHECK-DAG:     func doSomethingFun(_ operation: String) async
 // CHECK: {{^[}]$}}
+
+// CHECK-LABEL: protocol RefrigeratorDelegate
+// CHECK-NEXT: @asyncHandler func someoneDidOpenRefrigerator(_ fridge: Any)
+// CHECK-NEXT: @asyncHandler func refrigerator(_ fridge: Any, didGetFilledWithItems items: [Any])
+// CHECK-NEXT: {{^}}  func refrigerator(_ fridge: Any, didGetFilledWithIntegers items: UnsafeMutablePointer<Int>, count: Int)
+// CHECK-NEXT: {{^}}  func refrigerator(_ fridge: Any, willAddItem item: Any)
+// CHECK-NEXT: {{^}}  func refrigerator(_ fridge: Any, didRemoveItem item: Any) -> Bool
+// CHECK-NEXT: {{^[}]$}}

test/Inputs/clang-importer-sdk/usr/include/ObjCConcurrency.h

@@ -13,4 +13,12 @@
 @property(readwrite) void (^completionHandler)(NSInteger);
 @end
 
+@protocol RefrigeratorDelegate<NSObject>
+- (void)someoneDidOpenRefrigerator:(id)fridge;
+- (void)refrigerator:(id)fridge didGetFilledWithItems:(NSArray *)items;
+- (void)refrigerator:(id)fridge didGetFilledWithIntegers:(NSInteger *)items count:(NSInteger)count;
+- (void)refrigerator:(id)fridge willAddItem:(id)item;
+- (BOOL)refrigerator:(id)fridge didRemoveItem:(id)item;
+@end
+
 #pragma clang assume_nonnull end