Add friendlier error message on an explicit implementation when the return type is wrong

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -8196,4 +8196,10 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_AttributeCannotBeAppliedManually" xml:space="preserve">
     <value>'{0}' cannot be applied manually.</value>
   </data>
+  <data name="ERR_ExplicitInterfaceMemberTypeMismatch" xml:space="preserve">
+    <value>'{0}': type must be '{1}' to match implemented member '{2}'</value>
+  </data>
+  <data name="ERR_ExplicitInterfaceMemberReturnTypeMismatch" xml:space="preserve">
+    <value>'{0}': return type must be '{1}' to match implemented member '{2}'</value>
+  </data>
 </root>

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -2427,6 +2427,8 @@ internal enum ErrorCode
         ERR_MethodImplAttributeAsyncCannotBeUsed = 9330,
         ERR_AttributeCannotBeAppliedManually = 9331,
         ERR_BadSpreadInCatchFilter = 9332,
+        ERR_ExplicitInterfaceMemberTypeMismatch = 9333,
+        ERR_ExplicitInterfaceMemberReturnTypeMismatch = 9334,
 
         // Note: you will need to do the following after adding errors:
         //  1) Update ErrorFacts.IsBuildOnlyDiagnostic (src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs)

src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs

@@ -2536,6 +2536,8 @@ or ErrorCode.ERR_ExtensionBlockCollision
                 or ErrorCode.ERR_MethodImplAttributeAsyncCannotBeUsed
                 or ErrorCode.ERR_AttributeCannotBeAppliedManually
                 or ErrorCode.ERR_BadSpreadInCatchFilter
+                or ErrorCode.ERR_ExplicitInterfaceMemberTypeMismatch
+                or ErrorCode.ERR_ExplicitInterfaceMemberReturnTypeMismatch
                     => false,
             };
 #pragma warning restore CS8524 // The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.

src/Compilers/CSharp/Portable/Symbols/MemberSignatureComparer.cs

@@ -47,6 +47,18 @@ internal sealed class MemberSignatureComparer : IEqualityComparer<Symbol>
             considerCallingConvention: true,
             typeComparison: TypeCompareKind.AllIgnoreOptions);
 
+        /// <summary>
+        /// If this returns false, then the real explicit implementation comparer will also return false.
+        /// Skips checking whether the return type is equal.
+        /// </summary>
+        public static readonly MemberSignatureComparer ExplicitImplementationWithoutReturnTypeComparer = new MemberSignatureComparer(
+            considerName: false,
+            considerExplicitlyImplementedInterfaces: false,
+            considerReturnType: false,
+            refKindCompareMode: RefKindCompareMode.ConsiderDifferences | RefKindCompareMode.AllowRefReadonlyVsInMismatch,
+            considerCallingConvention: true,
+            typeComparison: TypeCompareKind.AllIgnoreOptions);
+
         /// <summary>
         /// This instance is used when trying to determine if one member implicitly implements another,
         /// according to the C# definition.

src/Compilers/CSharp/Portable/Symbols/Source/ExplicitInterfaceHelpers.cs

@@ -234,10 +234,13 @@ private static Symbol FindExplicitlyImplementedMember(
                 //do a lookup anyway
             }
 
+            // Found a matching member without checking the return type.
+            var foundMatchingMemberWithoutReturnTypeComparer = false;
             // Setting this flag to true does not imply that an interface member has been successfully implemented.
             // It just indicates that a corresponding interface member has been found (there may still be errors).
             var foundMatchingMember = false;
 
+            Symbol matchingMemberWithoutReturnTypeComparer = null;
             Symbol implementedMember = null;
 
             // Do not look in itself
@@ -265,7 +268,19 @@ private static Symbol FindExplicitlyImplementedMember(
                     continue;
                 }
 
-                if (MemberSignatureComparer.ExplicitImplementationComparer.Equals(implementingMember, interfaceMember))
+                if (!MemberSignatureComparer.ExplicitImplementationWithoutReturnTypeComparer.Equals(implementingMember, interfaceMember))
+                {
+                    continue;
+                }
+
+                var implementingMemberTypeMap = MemberSignatureComparer.GetTypeMap(implementingMember);
+                var interfaceMemberTypeMap = MemberSignatureComparer.GetTypeMap(interfaceMember);
+                if (MemberSignatureComparer.HaveSameReturnTypes(
+                        implementingMember,
+                        implementingMemberTypeMap,
+                        interfaceMember,
+                        interfaceMemberTypeMap,
+                        TypeCompareKind.AllIgnoreOptions))
                 {
                     foundMatchingMember = true;
                     // Cannot implement accessor directly unless
@@ -291,13 +306,30 @@ private static Symbol FindExplicitlyImplementedMember(
                         break;
                     }
                 }
+                else
+                {
+                    foundMatchingMemberWithoutReturnTypeComparer = true;
+                    matchingMemberWithoutReturnTypeComparer = interfaceMember;
+                }
             }
 
             if (!foundMatchingMember)
             {
-                // CONSIDER: we may wish to suppress this error in the event that another error
+                // CONSIDER: we may wish to suppress these errors in the event that another error
                 // has been reported about the signature.
-                diagnostics.Add(ErrorCode.ERR_InterfaceMemberNotFound, memberLocation, implementingMember);
+
+                if (foundMatchingMemberWithoutReturnTypeComparer)
+                {
+                    var errorType = implementingMember.Kind is SymbolKind.Method
+                        ? ErrorCode.ERR_ExplicitInterfaceMemberReturnTypeMismatch
+                        : ErrorCode.ERR_ExplicitInterfaceMemberTypeMismatch;
+                    var returnType = matchingMemberWithoutReturnTypeComparer.GetTypeOrReturnType();
+                    diagnostics.Add(errorType, memberLocation, implementingMember, returnType, matchingMemberWithoutReturnTypeComparer);
+                }
+                else
+                {
+                    diagnostics.Add(ErrorCode.ERR_InterfaceMemberNotFound, memberLocation, implementingMember);
+                }
             }
 
             // Make sure implemented member is accessible