[Amendment] SE-0296: Allow overloads that differ only in async

include/swift/AST/Decl.h

@@ -228,6 +228,9 @@ struct OverloadSignature {
   /// Whether this is a function.
   unsigned IsFunction : 1;
 
+  /// Whether this is an async function.
+  unsigned IsAsyncFunction : 1;
+
   /// Whether this is a enum element.
   unsigned IsEnumElement : 1;
 
@@ -249,8 +252,9 @@ struct OverloadSignature {
 
   OverloadSignature()
       : UnaryOperator(UnaryOperatorKind::None), IsInstanceMember(false),
-        IsVariable(false), IsFunction(false), InProtocolExtension(false),
-        InExtensionOfGenericType(false), HasOpaqueReturnType(false) { }
+        IsVariable(false), IsFunction(false), IsAsyncFunction(false),
+        InProtocolExtension(false), InExtensionOfGenericType(false),
+        HasOpaqueReturnType(false) { }
 };
 
 /// Determine whether two overload signatures conflict.

lib/AST/Decl.cpp

@@ -2483,6 +2483,10 @@ bool swift::conflicting(const OverloadSignature& sig1,
   if (sig1.IsInstanceMember != sig2.IsInstanceMember)
     return false;
 
+  // If one is an async function and the other is not, they can't conflict.
+  if (sig1.IsAsyncFunction != sig2.IsAsyncFunction)
+    return false;
+
   // If one is a compound name and the other is not, they do not conflict
   // if one is a property and the other is a non-nullary function.
   if (sig1.Name.isCompoundName() != sig2.Name.isCompoundName()) {
@@ -2709,7 +2713,6 @@ OverloadSignature ValueDecl::getOverloadSignature() const {
     = static_cast<bool>(getDeclContext()->getExtendedProtocolDecl());
   signature.IsInstanceMember = isInstanceMember();
   signature.IsVariable = isa<VarDecl>(this);
-  signature.IsFunction = isa<AbstractFunctionDecl>(this);
   signature.IsEnumElement = isa<EnumElementDecl>(this);
   signature.IsNominal = isa<NominalTypeDecl>(this);
   signature.IsTypeAlias = isa<TypeAliasDecl>(this);
@@ -2723,6 +2726,13 @@ OverloadSignature ValueDecl::getOverloadSignature() const {
     }
   }
 
+  // Functions include async/not-async.
+  if (auto func = dyn_cast<AbstractFunctionDecl>(this)) {
+    signature.IsFunction = true;
+    if (func->hasAsync())
+      signature.IsAsyncFunction = true;
+  }
+
   if (auto *extension = dyn_cast<ExtensionDecl>(getDeclContext()))
     if (extension->isGeneric())
       signature.InExtensionOfGenericType = true;

test/ClangImporter/objc_async_conformance.swift

@@ -20,12 +20,11 @@ extension C2 {
 }
 
 // a version of C2 that requires both sync and async methods (differing only by
-// completion handler) in ObjC, is not possible to conform to with 'async' in
-// a Swift protocol
+// completion handler) in ObjC.
 class C3 : NSObject, RequiredObserver {}
 extension C3 {
-  func hello() -> Bool { true } // expected-note {{'hello()' previously declared here}}
-  func hello() async -> Bool { true } // expected-error {{invalid redeclaration of 'hello()'}}
+  func hello() -> Bool { true }
+  func hello() async -> Bool { true }
 }
 
 // the only way to conform to 'RequiredObserver' in Swift is to not use 'async'

test/decl/func/async.swift

@@ -6,8 +6,8 @@
 func redecl1() async { } // expected-note{{previously declared here}}
 func redecl1() async throws { } // expected-error{{invalid redeclaration of 'redecl1()'}}
 
-func redecl2() -> String { "" } // expected-note{{previously declared here}}
-func redecl2() async -> String { "" } // expected-error{{invalid redeclaration of 'redecl2()'}}
+func redecl2() -> String { "" } // okay
+func redecl2() async -> String { "" } // okay
 
 // Override checking