[Concurrency] Import Objective-C methods with completion handlers as async

When a given Objective-C method has a completion handler parameter
with an appropriate signature, import that Objective-C method as
async. For example, consider the following CloudKit API:

    - (void)fetchShareParticipantWithUserRecordID:(CKRecordID
*)userRecordID
            completionHandler:(void (^)(CKShareParticipant * _Nullable shareParticipant, NSError * _Nullable error))completionHandler;

With the experimental concurrency model, this would import as:

    func fetchShareParticipant(withUserRecordID userRecordID: CKRecord.ID) async throws -> CKShare.Participant?

The compiler will be responsible for turning the caller's continuation
into a block to pass along to the completion handler. When the error
parameter of the completion handler is non-null, the async call
will result in that error being thrown. Otherwise, the other arguments
passed to that completion handler will be returned as the result of
the async call.

async versions of methods are imported alongside their
completion-handler versions, to maintain source compatibility with
existing code that provides a completion handler.

Note that this only covers the Clang importer portion of this task.

Author: DougGregor

include/swift/AST/Decl.h

@@ -63,6 +63,7 @@ namespace swift {
   class Type;
   class Expr;
   class DeclRefExpr;
+  class ForeignAsyncConvention;
   class ForeignErrorConvention;
   class LiteralExpr;
   class BraceStmt;
@@ -6148,7 +6149,15 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// being dropped altogether. `None` is returned for a normal function
   /// or method.
   Optional<int> getForeignFunctionAsMethodSelfParameterIndex() const;
-  
+
+  /// Set information about the foreign async convention used by this
+  /// declaration.
+  void setForeignAsyncConvention(const ForeignAsyncConvention &convention);
+
+  /// Get information about the foreign async convention used by this
+  /// declaration, given that it is @objc and 'async'.
+  Optional<ForeignAsyncConvention> getForeignAsyncConvention() const;
+
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_AbstractFunctionDecl &&
            D->getKind() <= DeclKind::Last_AbstractFunctionDecl;
@@ -6277,7 +6286,8 @@ class FuncDecl : public AbstractFunctionDecl {
                                   DeclContext *Parent);
 
   static FuncDecl *createImported(ASTContext &Context, SourceLoc FuncLoc,
-                                  DeclName Name, SourceLoc NameLoc, bool Throws,
+                                  DeclName Name, SourceLoc NameLoc,
+                                  bool Async, bool Throws,
                                   ParameterList *BodyParams, Type FnRetType,
                                   DeclContext *Parent, ClangNode ClangN);
 

include/swift/AST/ForeignAsyncConvention.h

@@ -0,0 +1,81 @@
+//===--- ForeignAsyncConvention.h - Async conventions -----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the ForeignAsyncConvention structure, which
+// describes the rules for how to detect that a foreign API is asynchronous.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_FOREIGN_ASYNC_CONVENTION_H
+#define SWIFT_FOREIGN_ASYNC_CONVENTION_H
+
+#include "swift/AST/Type.h"
+
+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()
+      : CompletionHandlerParamIndex(0), CompletionHandlerErrorParamIndex(0) { }
+
+  ForeignAsyncConvention(unsigned completionHandlerParamIndex,
+                         Optional<unsigned> completionHandlerErrorParamIndex)
+      : CompletionHandlerParamIndex(completionHandlerParamIndex),
+        CompletionHandlerErrorParamIndex(
+          completionHandlerErrorParamIndex
+            ? *completionHandlerErrorParamIndex + 1
+            : 0) {}
+
+  /// 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;
+  }
+
+  /// 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;
+  }
+
+  bool operator==(ForeignAsyncConvention other) const {
+    return CompletionHandlerParamIndex == other.CompletionHandlerParamIndex
+      && CompletionHandlerErrorParamIndex ==
+        other.CompletionHandlerErrorParamIndex;
+  }
+  bool operator!=(ForeignAsyncConvention other) const {
+    return !(*this == other);
+  }
+};
+
+}
+
+#endif

include/swift/AST/ForeignErrorConvention.h

@@ -81,6 +81,10 @@ class ForeignErrorConvention {
     }
 
     Info() = default;
+
+    Kind getKind() const {
+      return static_cast<Kind>(TheKind);
+    }
   };
 
 private:  
@@ -178,11 +182,24 @@ class ForeignErrorConvention {
   /// Returns the physical result type of the function, for functions
   /// that completely erase this information.
   CanType getResultType() const {
-    assert(getKind() == ZeroResult ||
-           getKind() == NonZeroResult);
+    assert(resultTypeErasedToVoid(getKind()));
     return ResultType;
   }
-  
+
+  /// Whether this kind of error import erases the result type to 'Void'.
+  static bool resultTypeErasedToVoid(Kind kind) {
+    switch (kind) {
+    case ZeroResult:
+    case NonZeroResult:
+      return true;
+
+    case ZeroPreservedResult:
+    case NilResult:
+    case NonNilError:
+      return false;
+    }
+  }
+
   bool operator==(ForeignErrorConvention other) const {
     return info.TheKind == other.info.TheKind
       && info.ErrorIsOwned == other.info.ErrorIsOwned

lib/AST/ASTContext.cpp

@@ -18,6 +18,7 @@
 #include "ClangTypeConverter.h"
 #include "ForeignRepresentationInfo.h"
 #include "SubstitutionMapStorage.h"
+#include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DiagnosticEngine.h"
@@ -281,6 +282,10 @@ struct ASTContext::Implementation {
   llvm::DenseMap<const AbstractFunctionDecl *,
                  ForeignErrorConvention> ForeignErrorConventions;
 
+  /// Map from declarations to foreign async conventions.
+  llvm::DenseMap<const AbstractFunctionDecl *,
+                 ForeignAsyncConvention> ForeignAsyncConventions;
+
   /// Cache of previously looked-up precedence queries.
   AssociativityCacheType AssociativityCache;
 
@@ -2238,6 +2243,24 @@ AbstractFunctionDecl::getForeignErrorConvention() const {
   return it->second;
 }
 
+void AbstractFunctionDecl::setForeignAsyncConvention(
+                                         const ForeignAsyncConvention &conv) {
+  assert(hasAsync() && "setting error convention on non-throwing decl");
+  auto &conventionsMap = getASTContext().getImpl().ForeignAsyncConventions;
+  assert(!conventionsMap.count(this) && "error convention already set");
+  conventionsMap.insert({this, conv});
+}
+
+Optional<ForeignAsyncConvention>
+AbstractFunctionDecl::getForeignAsyncConvention() const {
+  if (!hasAsync())
+    return None;
+  auto &conventionsMap = getASTContext().getImpl().ForeignAsyncConventions;
+  auto it = conventionsMap.find(this);
+  if (it == conventionsMap.end()) return None;
+  return it->second;
+}
+
 Optional<KnownFoundationEntity> swift::getKnownFoundationEntity(StringRef name){
   return llvm::StringSwitch<Optional<KnownFoundationEntity>>(name)
 #define FOUNDATION_ENTITY(Name) .Case(#Name, KnownFoundationEntity::Name)

lib/AST/Decl.cpp

@@ -7255,13 +7255,14 @@ FuncDecl *FuncDecl::createImplicit(ASTContext &Context,
 
 FuncDecl *FuncDecl::createImported(ASTContext &Context, SourceLoc FuncLoc,
                                    DeclName Name, SourceLoc NameLoc,
-                                   bool Throws, ParameterList *BodyParams,
+                                   bool Async, bool Throws,
+                                   ParameterList *BodyParams,
                                    Type FnRetType, DeclContext *Parent,
                                    ClangNode ClangN) {
   assert(ClangN && FnRetType);
   auto *const FD = FuncDecl::createImpl(
       Context, SourceLoc(), StaticSpellingKind::None, FuncLoc, Name, NameLoc,
-      /*Async=*/false, SourceLoc(), Throws, SourceLoc(),
+      Async, SourceLoc(), Throws, SourceLoc(),
       /*GenericParams=*/nullptr, Parent, ClangN);
   FD->setParameters(BodyParams);
   FD->setResultInterfaceType(FnRetType);

lib/ClangImporter/ClangImporter.cpp

@@ -3681,6 +3681,7 @@ void ClangImporter::Implementation::lookupValue(
             clangDecl->getMostRecentDecl();
 
         CurrentVersion.forEachOtherImportNameVersion(
+            SwiftContext.LangOpts.EnableExperimentalConcurrency,
             [&](ImportNameVersion nameVersion) {
           if (anyMatching)
             return;
@@ -3690,6 +3691,12 @@ void ClangImporter::Implementation::lookupValue(
           if (!newName.getDeclName().matchesRef(name))
             return;
 
+          // If we asked for an async import and didn't find one, skip this.
+          // This filters out duplicates.
+          if (nameVersion.supportsConcurrency() &&
+              !newName.getAsyncInfo())
+            return;
+
           const clang::DeclContext *clangDC =
               newName.getEffectiveContext().getAsDeclContext();
           if (!clangDC || !clangDC->isFileContext())

lib/ClangImporter/ImportDecl.cpp

@@ -160,6 +160,7 @@ static FuncDecl *createFuncOrAccessor(ASTContext &ctx, SourceLoc funcLoc,
                                       DeclName name, SourceLoc nameLoc,
                                       ParameterList *bodyParams,
                                       Type resultTy,
+                                      bool async,
                                       bool throws,
                                       DeclContext *dc,
                                       ClangNode clangNode) {
@@ -176,7 +177,7 @@ static FuncDecl *createFuncOrAccessor(ASTContext &ctx, SourceLoc funcLoc,
                                 bodyParams,
                                 resultTy, dc, clangNode);
   } else {
-    return FuncDecl::createImported(ctx, funcLoc, name, nameLoc, throws,
+    return FuncDecl::createImported(ctx, funcLoc, name, nameLoc, async, throws,
                                     bodyParams, resultTy, dc, clangNode);
   }
 }
@@ -2254,7 +2255,7 @@ namespace {
     /// Whether the names we're importing are from the language version the user
     /// requested, or if these are decls from another version
     bool isActiveSwiftVersion() const {
-      return getVersion() == getActiveSwiftVersion();
+      return getVersion().withConcurrency(false) == getActiveSwiftVersion().withConcurrency(false);
     }
 
     void recordMemberInContext(const DeclContext *dc, ValueDecl *member) {
@@ -2300,7 +2301,7 @@ namespace {
         return canonicalName;
       }
 
-      // Special handling when we import using the older Swift name.
+      // Special handling when we import using the alternate Swift name.
       //
       // Import using the alternate Swift name. If that fails, or if it's
       // identical to the active Swift name, we won't introduce an alternate
@@ -2309,6 +2310,19 @@ namespace {
       if (!alternateName)
         return ImportedName();
 
+      // Importing for concurrency is special in that the same declaration
+      // is imported both with a completion handler parameter and as 'async',
+      // creating two separate declarations.
+      if (getVersion().supportsConcurrency()) {
+        // If the resulting name isn't special for concurrency, it's not
+        // different.
+        if (!alternateName.getAsyncInfo())
+          return ImportedName();
+
+        // Otherwise, it's a legitimately different import.
+        return alternateName;
+      }
+
       if (alternateName.getDeclName() == canonicalName.getDeclName() &&
           alternateName.getEffectiveContext().equalsWithoutResolving(
               canonicalName.getEffectiveContext())) {
@@ -2470,6 +2484,13 @@ namespace {
           return;
       }
 
+      // If this the active and current Swift versions differ based on
+      // concurrency, it's not actually a variant.
+      if (getVersion().supportsConcurrency() !=
+            getActiveSwiftVersion().supportsConcurrency()) {
+        return;
+      }
+
       // TODO: some versions should be deprecated instead of unavailable
 
       ASTContext &ctx = decl->getASTContext();
@@ -3837,9 +3858,10 @@ namespace {
 
       // FIXME: Poor location info.
       auto nameLoc = Impl.importSourceLoc(decl->getLocation());
-      result = createFuncOrAccessor(Impl.SwiftContext, loc, accessorInfo, name,
-                                    nameLoc, bodyParams, resultTy,
-                                    /*throws*/ false, dc, decl);
+      result = createFuncOrAccessor(
+          Impl.SwiftContext, loc, accessorInfo, name,
+          nameLoc, bodyParams, resultTy,
+          /*async*/ false, /*throws*/ false, dc, decl);
 
       if (!dc->isModuleScopeContext()) {
         if (selfIsInOut)
@@ -4410,6 +4432,16 @@ namespace {
         }
       }
 
+      // Determine whether the function is throwing and/or async.
+      bool throws = importedName.getErrorInfo().hasValue();
+      bool async = false;
+      auto asyncConvention = importedName.getAsyncInfo();
+      if (asyncConvention) {
+        async = true;
+        if (asyncConvention->isThrowing())
+          throws = true;
+      }
+
       auto resultTy = importedType.getType();
       auto isIUO = importedType.isImplicitlyUnwrapped();
 
@@ -4439,8 +4471,7 @@ namespace {
                                          importedName.getDeclName(),
                                          /*nameLoc*/SourceLoc(),
                                          bodyParams, resultTy,
-                                         importedName.getErrorInfo().hasValue(),
-                                         dc, decl);
+                                         async, throws, dc, decl);
 
       result->setAccess(getOverridableAccessLevel(dc));
 
@@ -4472,6 +4503,11 @@ namespace {
         result->setForeignErrorConvention(*errorConvention);
       }
 
+      // Record the async convention.
+      if (asyncConvention) {
+        result->setForeignAsyncConvention(*asyncConvention);
+      }
+
       // Handle attributes.
       if (decl->hasAttr<clang::IBActionAttr>() &&
           isa<FuncDecl>(result) &&
@@ -4503,6 +4539,7 @@ namespace {
             Impl.addAlternateDecl(result, cast<ValueDecl>(imported));
         }
       }
+
       return result;
     }
 
@@ -6443,6 +6480,7 @@ ConstructorDecl *SwiftDeclConverter::importConstructor(
     return known->second;
 
   // Create the actual constructor.
+  assert(!importedName.getAsyncInfo());
   auto result = Impl.createDeclWithClangNode<ConstructorDecl>(
       objcMethod, AccessLevel::Public, importedName.getDeclName(),
       /*NameLoc=*/SourceLoc(), failability, /*FailabilityLoc=*/SourceLoc(),
@@ -7145,6 +7183,11 @@ void SwiftDeclConverter::importMirroredProtocolMembers(
       if (isa<AccessorDecl>(afd))
         return;
 
+      // Asynch methods are also always imported without async, so don't
+      // record them here.
+      if (afd->hasAsync())
+        return;
+
       auto objcMethod =
           dyn_cast_or_null<clang::ObjCMethodDecl>(member->getClangDecl());
       if (!objcMethod)