[Clang importer] Allow both sync and async imports with the same name.

The Clang importer was filtering out cases where the same declaration
is imported twice under the same name, which can now happen when one
is synchronous and one is asynchronous. This happens when, e.g., an
Objective-C class provides both a completion-hander-based asynchronous
version and a synchronous version, and the Swift names line up after
the completion-handler parameter is dropped.

Stop filtering these out. Overload resolution is capable of handling
synchronous/asynchronous overloading based on context.

Author: DougGregor

lib/ClangImporter/ClangImporter.cpp

@@ -3701,48 +3701,46 @@ void ClangImporter::Implementation::lookupValue(
 
     // If we have a declaration and nothing matched so far, try the names used
     // in other versions of Swift.
-    if (!anyMatching) {
-      if (auto clangDecl = entry.dyn_cast<clang::NamedDecl *>()) {
-        const clang::NamedDecl *recentClangDecl =
-            clangDecl->getMostRecentDecl();
-
-        CurrentVersion.forEachOtherImportNameVersion(
-            SwiftContext.LangOpts.EnableExperimentalConcurrency,
-            [&](ImportNameVersion nameVersion) {
-          if (anyMatching)
-            return;
-
-          // Check to see if the name and context match what we expect.
-          ImportedName newName = importFullName(recentClangDecl, nameVersion);
-          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())
-            return;
-
-          // Then try to import the decl under the alternate name.
-          auto alternateNamedDecl =
-              cast_or_null<ValueDecl>(importDeclReal(recentClangDecl,
-                                                     nameVersion));
-          if (!alternateNamedDecl || alternateNamedDecl == decl)
-            return;
-          assert(alternateNamedDecl->getName().matchesRef(name) &&
-                 "importFullName behaved differently from importDecl");
-          if (alternateNamedDecl->getDeclContext()->isModuleScopeContext()) {
-            consumer.foundDecl(alternateNamedDecl,
-                               DeclVisibilityKind::VisibleAtTopLevel);
-            anyMatching = true;
-          }
-        });
-      }
+    if (auto clangDecl = entry.dyn_cast<clang::NamedDecl *>()) {
+      const clang::NamedDecl *recentClangDecl =
+          clangDecl->getMostRecentDecl();
+
+      CurrentVersion.forEachOtherImportNameVersion(
+          SwiftContext.LangOpts.EnableExperimentalConcurrency,
+          [&](ImportNameVersion nameVersion) {
+        if (anyMatching)
+          return;
+
+        // Check to see if the name and context match what we expect.
+        ImportedName newName = importFullName(recentClangDecl, nameVersion);
+        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())
+          return;
+
+        // Then try to import the decl under the alternate name.
+        auto alternateNamedDecl =
+            cast_or_null<ValueDecl>(importDeclReal(recentClangDecl,
+                                                   nameVersion));
+        if (!alternateNamedDecl || alternateNamedDecl == decl)
+          return;
+        assert(alternateNamedDecl->getName().matchesRef(name) &&
+               "importFullName behaved differently from importDecl");
+        if (alternateNamedDecl->getDeclContext()->isModuleScopeContext()) {
+          consumer.foundDecl(alternateNamedDecl,
+                             DeclVisibilityKind::VisibleAtTopLevel);
+          anyMatching = true;
+        }
+      });
     }
   }
 }

lib/ClangImporter/ImportName.cpp

@@ -2084,13 +2084,15 @@ ImportedName NameImporter::importName(const clang::NamedDecl *decl,
 bool NameImporter::forEachDistinctImportName(
     const clang::NamedDecl *decl, ImportNameVersion activeVersion,
     llvm::function_ref<bool(ImportedName, ImportNameVersion)> action) {
-  using ImportNameKey = std::pair<DeclName, EffectiveClangContext>;
+  using ImportNameKey = std::tuple<DeclName, EffectiveClangContext, bool>;
   SmallVector<ImportNameKey, 8> seenNames;
 
   ImportedName newName = importName(decl, activeVersion);
   if (!newName)
     return true;
-  ImportNameKey key(newName.getDeclName(), newName.getEffectiveContext());
+
+  ImportNameKey key(newName.getDeclName(), newName.getEffectiveContext(),
+                    newName.getAsyncInfo().hasValue());
   if (action(newName, activeVersion))
     seenNames.push_back(key);
 
@@ -2101,15 +2103,18 @@ bool NameImporter::forEachDistinctImportName(
         ImportedName newName = importName(decl, nameVersion);
         if (!newName)
           return;
-        ImportNameKey key(newName.getDeclName(), newName.getEffectiveContext());
+        ImportNameKey key(newName.getDeclName(), newName.getEffectiveContext(),
+                          newName.getAsyncInfo().hasValue());
 
         bool seen = llvm::any_of(
             seenNames, [&key](const ImportNameKey &existing) -> bool {
-              return key.first == existing.first &&
-                     key.second.equalsWithoutResolving(existing.second);
+              return std::get<0>(key) == std::get<0>(existing) &&
+                std::get<2>(key) == std::get<2>(existing) &&
+                std::get<1>(key).equalsWithoutResolving(std::get<1>(existing));
             });
         if (seen)
           return;
+
         if (action(newName, nameVersion))
           seenNames.push_back(key);
       });

test/ClangImporter/objc_async.swift

@@ -11,6 +11,18 @@ func testSlowServer(slowServer: SlowServer) async throws {
   let _: String = await try slowServer.findAnswerFailingly() ?? "nope"
   let _: Void = await slowServer.doSomethingFun("jump")
   let _: (Int) -> Void = slowServer.completionHandler
+
+  // async version
+  let _: Int = await slowServer.doSomethingConflicted("thinking")
+
+  // still async version...
+  let _: Int = slowServer.doSomethingConflicted("thinking")
+  // expected-error@-1{{call is 'async' but is not marked with 'await'}}
+}
+
+func testSlowServerSynchronous(slowServer: SlowServer) {
+  // synchronous version
+  let _: Int = slowServer.doSomethingConflicted("thinking")
 }
 
 func testSlowServerOldSchool(slowServer: SlowServer) {

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

@@ -11,6 +11,9 @@
 -(BOOL)findAnswerFailinglyWithError:(NSError * _Nullable * _Nullable)error completion:(void (^)(NSString *_Nullable, NSError * _Nullable))handler __attribute__((swift_name("findAnswerFailingly(completionHandler:)")));
 -(void)doSomethingFun:(NSString *)operation then:(void (^)(void))completionHandler;
 @property(readwrite) void (^completionHandler)(NSInteger);
+
+-(void)doSomethingConflicted:(NSString *)operation completionHandler:(void (^)(NSInteger))handler;
+-(NSInteger)doSomethingConflicted:(NSString *)operation;
 @end
 
 @protocol RefrigeratorDelegate<NSObject>
@@ -21,4 +24,11 @@
 - (BOOL)refrigerator:(id)fridge didRemoveItem:(id)item;
 @end
 
+@protocol ConcurrentProtocol
+-(void)askUserToSolvePuzzle:(NSString *)puzzle completionHandler:(void (^ _Nullable)(NSString * _Nullable, NSError * _Nullable))completionHandler;
+
+@optional
+-(void)askUserToJumpThroughHoop:(NSString *)hoop completionHandler:(void (^ _Nullable)(NSString *))completionHandler;
+@end
+
 #pragma clang assume_nonnull end