Merge pull request swiftlang#35955 from DougGregor/se-0297-default

Author: DougGregor

CHANGELOG.md

@@ -75,6 +75,31 @@ Swift Next
   }
   ```
 
+* [SE-0297][]:
+
+  An Objective-C method that delivers its results asynchronously via a completion handler block will be translated into an `async` method that directly returns the result (or throws). For example, the following Objective-C method from [CloudKit](https://developer.apple.com/documentation/cloudkit/ckcontainer/1640387-fetchshareparticipantwithuserrec):
+
+  ```objc
+  - (void)fetchShareParticipantWithUserRecordID:(CKRecordID *)userRecordID
+      completionHandler:(void (^)(CKShareParticipant * _Nullable, NSError * _Nullable))completionHandler;
+  ```
+
+  will be translated into an `async throws` method that returns the participant instance:
+
+  ```swift
+  func fetchShareParticipant(
+      withUserRecordID userRecordID: CKRecord.ID
+  ) async throws -> CKShare.Participant
+  ```
+
+  Swift callers can invoke this `async` method within an `await` expression:
+
+  ```swift
+  guard let participant = try? await container.fetchShareParticipant(withUserRecordID: user) else {
+      return nil
+  }
+  ```
+
 * [SE-0298][]:
 
   The "for" loop can be used to traverse asynchronous sequences in asynchronous code:
@@ -8336,6 +8361,7 @@ Swift 1.0
 [SE-0286]: <https://github.com/apple/swift-evolution/blob/main/proposals/0286-forward-scan-trailing-closures.md>
 [SE-0287]: <https://github.com/apple/swift-evolution/blob/main/proposals/0287-implicit-member-chains.md>
 [SE-0296]: <https://github.com/apple/swift-evolution/blob/main/proposals/0296-async-await.md>
+[SE-0297]: <https://github.com/apple/swift-evolution/blob/main/proposals/0297-concurrency-objc.md>
 [SE-0298]: <https://github.com/apple/swift-evolution/blob/main/proposals/0298-asyncsequence.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>

lib/ClangImporter/ClangImporter.cpp

@@ -3781,7 +3781,6 @@ void ClangImporter::Implementation::lookupValue(
           clangDecl->getMostRecentDecl();
 
       CurrentVersion.forEachOtherImportNameVersion(
-          SwiftContext.LangOpts.EnableExperimentalConcurrency,
           [&](ImportNameVersion nameVersion) {
         if (anyMatching)
           return;

lib/ClangImporter/ImportDecl.cpp

@@ -7700,8 +7700,7 @@ void SwiftDeclConverter::importNonOverriddenMirroredMethods(DeclContext *dc,
           members.push_back(alternate);
       }
 
-      if (Impl.SwiftContext.LangOpts.EnableExperimentalConcurrency &&
-          !getVersion().supportsConcurrency()) {
+      if (!getVersion().supportsConcurrency()) {
         auto asyncVersion = getVersion().withConcurrency(true);
         if (auto asyncImport = Impl.importMirroredDecl(
                 objcMethod, dc, asyncVersion, proto)) {
@@ -9090,12 +9089,10 @@ ClangImporter::Implementation::createConstant(Identifier name, DeclContext *dc,
 
   // Mark the function transparent so that we inline it away completely.
   func->getAttrs().add(new (C) TransparentAttr(/*implicit*/ true));
-  // If we're in concurrency mode, mark the constant as @actorIndependent
-  if (SwiftContext.LangOpts.EnableExperimentalConcurrency) {
-    auto actorIndependentAttr = new (C) ActorIndependentAttr(
-        ActorIndependentKind::Unsafe, /*IsImplicit=*/true);
-    var->getAttrs().add(actorIndependentAttr);
-  }
+  auto actorIndependentAttr = new (C) ActorIndependentAttr(
+      ActorIndependentKind::Unsafe, /*IsImplicit=*/true);
+  var->getAttrs().add(actorIndependentAttr);
+
   // Set the function up as the getter.
   makeComputed(var, func, nullptr);
 

lib/ClangImporter/ImportName.cpp

@@ -2249,7 +2249,6 @@ bool NameImporter::forEachDistinctImportName(
     seenNames.push_back(key);
 
   activeVersion.forEachOtherImportNameVersion(
-      swiftCtx.LangOpts.EnableExperimentalConcurrency,
       [&](ImportNameVersion nameVersion) {
         // Check to see if the name is different.
         ImportedName newName = importName(decl, nameVersion);

lib/ClangImporter/ImportName.h

@@ -116,18 +116,14 @@ class ImportNameVersion : public RelationalOperationsBase<ImportNameVersion> {
   ///
   /// This is the most useful order for importing compatibility stubs.
   void forEachOtherImportNameVersion(
-      bool withConcurrency,
       llvm::function_ref<void(ImportNameVersion)> action) const {
     assert(*this >= ImportNameVersion::swift2());
 
     ImportNameVersion nameVersion = *this;
     assert(!nameVersion.supportsConcurrency());
 
-    // If we've been asked to also consider concurrency, do so for the
-    // primary version (only).
-    if (withConcurrency) {
-      action(nameVersion.withConcurrency(true));
-    }
+    // Consider concurrency imports.
+    action(nameVersion.withConcurrency(true));
 
     while (nameVersion > ImportNameVersion::swift2()) {
       --nameVersion.rawValue;

lib/ClangImporter/SwiftLookupTable.cpp

@@ -1857,7 +1857,6 @@ SwiftNameLookupExtension::hashExtension(llvm::hash_code code) const {
                             SWIFT_LOOKUP_TABLE_VERSION_MAJOR,
                             SWIFT_LOOKUP_TABLE_VERSION_MINOR,
                             inferImportAsMember,
-                            swiftCtx.LangOpts.EnableExperimentalConcurrency,
                             version::getSwiftFullVersion());
 }