[typechecker] use mapSignatureFunctionType in getOverloadSignatureType() to compute the type for the enum element decl, etc

Author: Suyash Srijan

include/swift/AST/Decl.h

@@ -213,9 +213,6 @@ struct OverloadSignature {
   /// Whether this is a function.
   unsigned IsFunction : 1;
 
-  /// Whether this is a static function.
-  unsigned IsStaticFunction : 1;
-
   /// Whether this is a enum element.
   unsigned IsEnumElement : 1;
 

lib/AST/Decl.cpp

@@ -2090,12 +2090,15 @@ bool swift::conflicting(ASTContext &ctx,
   if (!conflicting(sig1, sig2, skipProtocolExtensionCheck))
     return false;
 
-  // Static functions do not conflict with enum element decls if the types
-  // are different
-  if (sig1.IsStaticFunction == sig2.IsEnumElement) {
-    if (sig1Type != sig2Type) {
-      return false;
-    }
+  // Two enum elements always conflict with each other. At this point, they
+  // have the same base name but different types.
+  if (sig1.IsEnumElement == sig2.IsEnumElement) {
+    return true;
+  }
+
+  // A function does not conflict with an enum element if their types differ.
+  if (sig1.IsFunction == sig2.IsEnumElement && sig1Type != sig2Type) {
+    return false;
   }
 
   // Functions always conflict with non-functions with the same signature.
@@ -2257,8 +2260,6 @@ OverloadSignature ValueDecl::getOverloadSignature() const {
   signature.IsVariable = isa<VarDecl>(this);
   signature.IsFunction = isa<AbstractFunctionDecl>(this);
   signature.IsEnumElement = isa<EnumElementDecl>(this);
-  signature.IsStaticFunction =
-      isa<FuncDecl>(this) && cast<FuncDecl>(this)->isStatic();
 
   // Unary operators also include prefix/postfix.
   if (auto func = dyn_cast<FuncDecl>(this)) {
@@ -2305,7 +2306,10 @@ CanType ValueDecl::getOverloadSignatureType() const {
   }
 
   if (isa<EnumElementDecl>(this)) {
-    return this->getInterfaceType()->getCanonicalType();
+    auto mappedType = mapSignatureFunctionType(
+        getASTContext(), getInterfaceType(), /*topLevelFunction=*/false,
+        /*isMethod=*/false, /*isInitializer=*/false, /*curryLevels=*/0);
+    return mappedType->getCanonicalType();
   }
 
   // Note: If you add more cases to this function, you should update the

test/decl/overload.swift

@@ -492,4 +492,28 @@ enum SR_10084_E {
   static func foo(_ value: SR_10084_S) -> SR_10084_E { // expected-error {{invalid redeclaration of 'foo'}}
     return .foo(value)
   }
-}
+}
+
+enum SR_10084_E_1 {
+  static func foo(_ name: String) -> SR_10084_E_1 { // expected-note {{'foo' previously declared here}}
+    return .foo(SR_10084_S(name: name))
+  }
+
+  static func foo(_ value: SR_10084_S) -> SR_10084_E_1 { // expected-error {{invalid redeclaration of 'foo'}}
+    return .foo(value)
+  }
+
+  case foo(SR_10084_S)
+}
+
+enum SR_10084_E_2 {
+  case fn(() -> Void) // expected-note {{'fn' previously declared here}}
+
+  static func fn(_ x: @escaping () -> Void) -> SR_10084_E_2 { // expected-error {{invalid redeclaration of 'fn'}}
+    fatalError()
+  }
+
+  static func fn(_ x: @escaping () -> Int) -> SR_10084_E_2 { // Ok
+    fatalError()
+  }
+}