[Concurrency] Allow @objc async methods.

Allow the declaration of @objc async methods, mapping them to a
completion-handler API in Objective-C. This covers most of the
checking and semantics within the type checker:
* Declaring @objc async methods and checking their parameter/result types
* Determining the default Objective-C selector by adding
completionHandler/WithCompletionHandler as appropriate
* Determining the type of the completion handler parameter
* Inferring @objc from protocol requirements
* Inferring @objc from an overridden method

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -1384,6 +1384,8 @@ ERROR(cdecl_empty_name,none,
       "@_cdecl symbol name cannot be empty", ())
 ERROR(cdecl_throws,none,
       "raising errors from @_cdecl functions is not supported", ())
+ERROR(cdecl_async,none,
+      "@_cdecl functions cannot be asynchronous", ())
 
 ERROR(attr_methods_only,none,
       "only methods can be declared %0", (DeclAttribute))
@@ -4117,6 +4119,17 @@ ERROR(asynchandler_mutating,none,
       "'@asyncHandler' function cannot be 'mutating'",
       ())
 
+ERROR(objc_ambiguous_async_convention,none,
+      "%0 overrides or implements protocol requirements for Objective-C "
+      "declarations with incompatible async conventions",
+      (DeclName))
+NOTE(objc_ambiguous_async_convention_candidate,none,
+     "%0 provides async here", (DeclName))
+
+ERROR(satisfy_async_objc,none,
+      "satisfying an asychronous @objc %select{method|initializer}0 with "
+      "a synchronous %select{method|initializer}0 is not supported", (bool))
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Types
 //------------------------------------------------------------------------------

include/swift/AST/ForeignAsyncConvention.h

@@ -24,53 +24,96 @@ namespace swift {
 
 /// A small structure describing the async convention of a foreign declaration.
 class ForeignAsyncConvention {
-  /// The index of the completion handler parameters.
-  unsigned CompletionHandlerParamIndex;
-
-  /// When non-zero, indicates which parameter to the completion handler is the
-  /// Error? parameter (minus one) that makes this async function also throwing.
-  unsigned CompletionHandlerErrorParamIndex;
 public:
-  ForeignAsyncConvention()
+  struct Info {
+    /// The index of the completion handler parameters.
+    unsigned CompletionHandlerParamIndex;
+
+    /// When non-zero, indicates which parameter to the completion handler is
+    /// the Error? parameter (minus one) that makes this async function also
+    /// throwing.
+    unsigned CompletionHandlerErrorParamIndex;
+
+    Info()
       : CompletionHandlerParamIndex(0), CompletionHandlerErrorParamIndex(0) { }
 
-  ForeignAsyncConvention(unsigned completionHandlerParamIndex,
-                         Optional<unsigned> completionHandlerErrorParamIndex)
+    Info(
+        unsigned completionHandlerParamIndex,
+        Optional<unsigned> completionHandlerErrorParamIndex)
       : CompletionHandlerParamIndex(completionHandlerParamIndex),
         CompletionHandlerErrorParamIndex(
-          completionHandlerErrorParamIndex
-            ? *completionHandlerErrorParamIndex + 1
-            : 0) {}
+            completionHandlerErrorParamIndex
+              ? *completionHandlerErrorParamIndex + 1
+              : 0) {}
+
+    /// Retrieve the index of the \c Error? parameter in the completion handler's
+    /// parameter list. When argument passed to this parameter is non-null, the
+    /// provided error will be thrown by the async function.
+    Optional<unsigned> completionHandlerErrorParamIndex() const {
+      if (CompletionHandlerErrorParamIndex == 0)
+        return None;
+
+      return CompletionHandlerErrorParamIndex - 1;
+    }
+
+    /// Whether the async function is throwing due to the completion handler
+    /// having an \c Error? parameter.
+    ///
+    /// Equivalent to \c static_cast<bool>(completionHandlerErrorParamIndex()).
+    bool isThrowing() const {
+      return CompletionHandlerErrorParamIndex != 0;
+    }
+  };
+
+  /// The type of the completion handler parameter.
+  CanType CompletionHandlerType;
+
+  /// Information about the async convention that can be determined from an
+  /// Objective-C declaration by itself.
+  Info TheInfo;
+
+public:
+  ForeignAsyncConvention() : TheInfo() { }
+
+  ForeignAsyncConvention(CanType completionHandlerType,
+                         unsigned completionHandlerParamIndex,
+                         Optional<unsigned> completionHandlerErrorParamIndex)
+      : CompletionHandlerType(completionHandlerType),
+        TheInfo(completionHandlerParamIndex, completionHandlerErrorParamIndex)
+  { }
+
+  /// Retrieve the type of the completion handler parameter.
+  CanType completionHandlerType() const { return CompletionHandlerType; }
 
   /// Retrieve the index of the completion handler parameter, which will be
   /// erased from the Swift signature of the imported async function.
   unsigned completionHandlerParamIndex() const {
-    return CompletionHandlerParamIndex;
+    return TheInfo.CompletionHandlerParamIndex;
   }
 
   /// Retrieve the index of the \c Error? parameter in the completion handler's
   /// parameter list. When argument passed to this parameter is non-null, the
   /// provided error will be thrown by the async function.
   Optional<unsigned> completionHandlerErrorParamIndex() const {
-    if (CompletionHandlerErrorParamIndex == 0)
-      return None;
-
-    return CompletionHandlerErrorParamIndex - 1;
+    return TheInfo.completionHandlerErrorParamIndex();
   }
 
   /// Whether the async function is throwing due to the completion handler
   /// having an \c Error? parameter.
   ///
   /// Equivalent to \c static_cast<bool>(completionHandlerErrorParamIndex()).
   bool isThrowing() const {
-    return CompletionHandlerErrorParamIndex != 0;
+    return TheInfo.isThrowing();
   }
 
   bool operator==(ForeignAsyncConvention other) const {
-    return CompletionHandlerParamIndex == other.CompletionHandlerParamIndex
-      && CompletionHandlerErrorParamIndex ==
-        other.CompletionHandlerErrorParamIndex;
+    return CompletionHandlerType == other.CompletionHandlerType
+        && TheInfo.CompletionHandlerParamIndex ==
+          other.TheInfo.CompletionHandlerParamIndex
+        && TheInfo.CompletionHandlerErrorParamIndex ==
+          other.TheInfo.CompletionHandlerErrorParamIndex;
   }
+
   bool operator!=(ForeignAsyncConvention other) const {
     return !(*this == other);
   }

lib/AST/ASTDumper.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/ASTPrinter.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ClangModuleLoader.h"
+#include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Initializer.h"
@@ -955,6 +956,16 @@ namespace {
         D->getCaptureInfo().print(OS);
       }
 
+      if (auto fac = D->getForeignAsyncConvention()) {
+        OS << " foreign_async=";
+        if (auto type = fac->completionHandlerType())
+          type.print(OS);
+        OS << ",completion_handler_param="
+           << fac->completionHandlerParamIndex();
+        if (auto errorParamIndex = fac->completionHandlerErrorParamIndex())
+          OS << ",error_param=" << *errorParamIndex;
+      }
+
       if (auto fec = D->getForeignErrorConvention()) {
         OS << " foreign_error=";
         OS << getForeignErrorConventionKindString(fec->getKind());

lib/AST/ASTVerifier.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Expr.h"
+#include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignature.h"
@@ -2994,8 +2995,23 @@ class Verifier : public ASTWalker {
         }
       }
 
-      // Throwing @objc methods must have a foreign error convention.
+      // Asynchronous @objc methods must have a foreign async convention.
       if (AFD->isObjC() &&
+          static_cast<bool>(AFD->getForeignAsyncConvention())
+            != AFD->hasAsync()) {
+        if (AFD->hasAsync())
+          Out << "@objc method async but does not have a foreign async "
+              << "convention";
+        else
+          Out << "@objc method has a foreign async convention but is not "
+              << "async";
+        abort();
+      }
+
+      // Synchronous throwing @objc methods must have a foreign error
+      // convention.
+      if (AFD->isObjC() &&
+          !AFD->hasAsync() &&
           static_cast<bool>(AFD->getForeignErrorConvention())
             != AFD->hasThrows()) {
         if (AFD->hasThrows())

lib/AST/Decl.cpp

@@ -24,6 +24,7 @@
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Expr.h"
+#include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignature.h"
@@ -6910,10 +6911,13 @@ AbstractFunctionDecl::getObjCSelector(DeclName preferredName,
   }
 
   // The number of selector pieces we'll have.
+  Optional<ForeignAsyncConvention> asyncConvention
+    = getForeignAsyncConvention();
   Optional<ForeignErrorConvention> errorConvention
     = getForeignErrorConvention();
   unsigned numSelectorPieces
-    = argNames.size() + (errorConvention.hasValue() ? 1 : 0);
+    = argNames.size() + (asyncConvention.hasValue() ? 1 : 0)
+    + (errorConvention.hasValue() ? 1 : 0);
 
   // If we have no arguments, it's a nullary selector.
   if (numSelectorPieces == 0) {
@@ -6932,6 +6936,14 @@ AbstractFunctionDecl::getObjCSelector(DeclName preferredName,
   unsigned argIndex = 0;
   for (unsigned piece = 0; piece != numSelectorPieces; ++piece) {
     if (piece > 0) {
+      // If we have an async convention that inserts a completion handler
+      // parameter here, add "completionHandler".
+      if (asyncConvention &&
+          piece == asyncConvention->completionHandlerParamIndex()) {
+        selectorPieces.push_back(ctx.getIdentifier("completionHandler"));
+        continue;
+      }
+
       // If we have an error convention that inserts an error parameter
       // here, add "error".
       if (errorConvention &&
@@ -6945,12 +6957,21 @@ AbstractFunctionDecl::getObjCSelector(DeclName preferredName,
       continue;
     }
 
-    // For the first selector piece, attach either the first parameter
-    // or "AndReturnError" to the base name, if appropriate.
+    // For the first selector piece, attach either the first parameter,
+    // "withCompletionHandker", or "AndReturnError" to the base name,
+    // if appropriate.
     auto firstPiece = baseName;
     llvm::SmallString<32> scratch;
     scratch += firstPiece.str();
-    if (errorConvention && piece == errorConvention->getErrorParameterIndex()) {
+    if (asyncConvention &&
+        piece == asyncConvention->completionHandlerParamIndex()) {
+      // The completion handler is first; append "WithCompletionHandler".
+      camel_case::appendSentenceCase(scratch, "WithCompletionHandler");
+
+      firstPiece = ctx.getIdentifier(scratch);
+      didStringManipulation = true;
+    } else if (errorConvention &&
+               piece == errorConvention->getErrorParameterIndex()) {
       // The error is first; append "AndReturnError".
       camel_case::appendSentenceCase(scratch, "AndReturnError");
 

lib/ClangImporter/ImportDecl.cpp

@@ -4380,6 +4380,7 @@ namespace {
         kind = SpecialMethodKind::NSDictionarySubscriptGetter;
 
       // Import the type that this method will have.
+      Optional<ForeignAsyncConvention> asyncConvention;
       Optional<ForeignErrorConvention> errorConvention;
 
       // If we have a property accessor, find the corresponding property
@@ -4418,7 +4419,7 @@ namespace {
         importedType = Impl.importMethodParamsAndReturnType(
             dc, decl, decl->parameters(), decl->isVariadic(),
             isInSystemModule(dc), &bodyParams, importedName,
-            errorConvention, kind);
+            asyncConvention, errorConvention, kind);
       }
       if (!importedType)
         return nullptr;
@@ -4440,10 +4441,10 @@ namespace {
       // Determine whether the function is throwing and/or async.
       bool throws = importedName.getErrorInfo().hasValue();
       bool async = false;
-      auto asyncConvention = importedName.getAsyncInfo();
-      if (asyncConvention) {
+      auto asyncInfo = importedName.getAsyncInfo();
+      if (asyncInfo) {
         async = true;
-        if (asyncConvention->isThrowing())
+        if (asyncInfo->isThrowing())
           throws = true;
       }
 
@@ -6381,11 +6382,14 @@ ConstructorDecl *SwiftDeclConverter::importConstructor(
   assert(ownerNominal && "Method in non-type context?");
 
   // Import the type that this method will have.
+  Optional<ForeignAsyncConvention> asyncConvention;
   Optional<ForeignErrorConvention> errorConvention;
   ParameterList *bodyParams;
   auto importedType = Impl.importMethodParamsAndReturnType(
       dc, objcMethod, args, variadic, isInSystemModule(dc), &bodyParams,
-      importedName, errorConvention, SpecialMethodKind::Constructor);
+      importedName, asyncConvention, errorConvention,
+      SpecialMethodKind::Constructor);
+  assert(!asyncConvention && "Initializers don't have async conventions");
   if (!importedType)
     return nullptr;
 

lib/ClangImporter/ImportName.cpp

@@ -1185,7 +1185,7 @@ static bool isNullableNSErrorType(
   return true;
 }
 
-Optional<ForeignAsyncConvention>
+Optional<ForeignAsyncConvention::Info>
 NameImporter::considerAsyncImport(
     const clang::ObjCMethodDecl *clangDecl,
     StringRef &baseName,
@@ -1211,7 +1211,8 @@ NameImporter::considerAsyncImport(
   // Determine whether the naming indicates that this is a completion
   // handler.
   Optional<StringRef> newBaseName;
-  if (isCompletionHandlerParamName(paramNames[completionHandlerParamNameIndex])) {
+  if (isCompletionHandlerParamName(
+          paramNames[completionHandlerParamNameIndex])) {
     // The argument label itself has an appropriate name.
   } else if (!hasCustomName && completionHandlerParamIndex == 0 &&
              (newBaseName = isCompletionHandlerInBaseName(baseName))) {
@@ -1226,7 +1227,8 @@ NameImporter::considerAsyncImport(
   // Used for returns once we've determined that the method cannot be
   // imported as async, even though it has what looks like a completion handler
   // parameter.
-  auto notAsync = [&](const char *reason) -> Optional<ForeignAsyncConvention> {
+  auto notAsync = [&](const char *reason) ->
+      Optional<ForeignAsyncConvention::Info> {
 #ifdef ASYNC_IMPORT_DEBUG
     llvm::errs() << "*** failed async import: " << reason << "\n";
     clangDecl->dump(llvm::errs());
@@ -1306,7 +1308,7 @@ NameImporter::considerAsyncImport(
   if (newBaseName && !hasCustomName)
     baseName = *newBaseName;
 
-  return ForeignAsyncConvention(
+  return ForeignAsyncConvention::Info(
       completionHandlerParamIndex, completionHandlerErrorParamIndex);
 }
 

lib/ClangImporter/ImportName.h

@@ -200,7 +200,7 @@ class ImportedName {
 
     /// For names that map Objective-C completion handlers into async
     /// Swift methods, describes how the mapping is performed.
-    ForeignAsyncConvention asyncInfo;
+    ForeignAsyncConvention::Info asyncInfo;
 
     /// For a declaration name that makes the declaration into an
     /// instance member, the index of the "Self" parameter.
@@ -270,7 +270,7 @@ class ImportedName {
 
   /// For names that map Objective-C methods with completion handlers into
   /// async Swift methods, describes how the mapping is performed.
-  Optional<ForeignAsyncConvention> getAsyncInfo() const {
+  Optional<ForeignAsyncConvention::Info> getAsyncInfo() const {
     if (info.hasAsyncInfo)
       return info.asyncInfo;
     return None;
@@ -453,7 +453,7 @@ class NameImporter {
                       ArrayRef<const clang::ParmVarDecl *> params,
                       bool isInitializer, bool hasCustomName);
 
-  Optional<ForeignAsyncConvention>
+  Optional<ForeignAsyncConvention::Info>
   considerAsyncImport(const clang::ObjCMethodDecl *clangDecl,
                       StringRef &baseName,
                       SmallVectorImpl<StringRef> &paramNames,