Relax signature collision rules for static extension methods (#77603)

Specifically, two static extension methods are allowed to have the same signature
(according to the current language rules) as long as all the following conditions are met:
- methods have different return type and/or different return ref-ness
- methods extending different types (ref-ness of the receiver parameter is not considered)

Author: AlekseyTs

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

@@ -101,6 +101,18 @@ internal sealed class MemberSignatureComparer : IEqualityComparer<Symbol>
             refKindCompareMode: RefKindCompareMode.DoNotConsiderDifferences,
             typeComparison: TypeCompareKind.AllIgnoreOptions);
 
+        /// <summary>
+        /// Same as <see cref="DuplicateSourceComparer"/>, but also considers return type_and_ref-ness differences
+        /// </summary>
+        public static readonly MemberSignatureComparer DuplicateSourceWithReturnComparer = new MemberSignatureComparer(
+            considerName: true,
+            considerExplicitlyImplementedInterfaces: true,
+            considerReturnType: true,
+            considerTypeConstraints: false,
+            considerCallingConvention: false,
+            refKindCompareMode: RefKindCompareMode.DoNotConsiderDifferences,
+            typeComparison: TypeCompareKind.AllIgnoreOptions);
+
         /// <summary>
         /// This instance is used to determine if some API specific to records is explicitly declared.
         /// It is the same as <see cref="DuplicateSourceComparer"/> except it considers ref kinds as well.

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

@@ -1972,6 +1972,9 @@ private void CheckMemberNameConflicts(BindingDiagnosticBag diagnostics)
             var conversionsAsMethods = new Dictionary<MethodSymbol, SourceMemberMethodSymbol>(MemberSignatureComparer.DuplicateSourceComparer);
             var conversionsAsConversions = new HashSet<SourceUserDefinedConversionSymbol>(ConversionSignatureComparer.Comparer);
 
+            Dictionary<MethodSymbol, OneOrMany<MethodSymbol>>? staticExtensionImplementationsWithoutReturn = null;
+            Dictionary<MethodSymbol, MethodSymbol>? staticExtensionImplementationsWithReturn = null;
+
             // SPEC: The signature of an operator must differ from the signatures of all other
             // SPEC: operators declared in the same class.
 
@@ -2113,11 +2116,89 @@ private void CheckMemberNameConflicts(BindingDiagnosticBag diagnostics)
                         {
                             ReportMethodSignatureCollision(diagnostics, conversion, previousMethod);
                         }
+
+                        if (staticExtensionImplementationsWithoutReturn?.TryGetValue(conversion, out OneOrMany<MethodSymbol> previousStaticExtension) == true)
+                        {
+                            Debug.Assert(false); // At the moment this code path is not reachable because implementation methods always come after all user defined methods
+                            ReportMethodSignatureCollision(diagnostics, conversion, previousStaticExtension.First());
+                        }
+
                         // Do not add the conversion to the set of previously-seen methods; that set
                         // is only non-conversion methods.
                     }
+                    else if (symbol is SourceExtensionImplementationMethodSymbol { UnderlyingMethod.IsStatic: true } staticExtension)
+                    {
+                        staticExtensionImplementationsWithReturn ??= new Dictionary<MethodSymbol, MethodSymbol>(MemberSignatureComparer.DuplicateSourceWithReturnComparer);
+
+                        // Does this method collide with any previously-seen static extension implementation?
+                        if (staticExtensionImplementationsWithReturn.TryGetValue(staticExtension, out var fullMatch))
+                        {
+                            ReportMethodSignatureCollision(diagnostics, staticExtension, fullMatch);
+                        }
+                        else
+                        {
+                            staticExtensionImplementationsWithReturn.Add(staticExtension, staticExtension);
+
+                            staticExtensionImplementationsWithoutReturn ??= new Dictionary<MethodSymbol, OneOrMany<MethodSymbol>>(MemberSignatureComparer.DuplicateSourceComparer);
+
+                            if (staticExtensionImplementationsWithoutReturn.TryGetValue(staticExtension, out OneOrMany<MethodSymbol> previousStaticExtension))
+                            {
+                                NamedTypeSymbol extension = staticExtension.UnderlyingMethod.ContainingType;
+                                var extensionParameter = extension.ExtensionParameter;
+                                bool foundExtendedTypeConflict = false;
+
+                                if (extensionParameter is not null)
+                                {
+                                    foreach (SourceExtensionImplementationMethodSymbol partialMatch in previousStaticExtension)
+                                    {
+                                        NamedTypeSymbol partialMatchExtension = partialMatch.UnderlyingMethod.ContainingType;
+                                        if (extension.Arity != partialMatchExtension.Arity ||
+                                            partialMatchExtension.ExtensionParameter is not { } partialMatchExtensionParameter)
+                                        {
+                                            continue;
+                                        }
+
+                                        if (extensionParameter.Type.Equals(
+                                                extension.Arity == 0 ?
+                                                    partialMatchExtensionParameter.Type :
+                                                    (new TypeMap(partialMatchExtension.TypeParameters, extension.TypeParameters)).SubstituteType(partialMatchExtensionParameter.Type).Type,
+                                                TypeCompareKind.AllIgnoreOptions))
+                                        {
+                                            foundExtendedTypeConflict = true;
+                                            ReportMethodSignatureCollision(diagnostics, staticExtension, partialMatch);
+                                            break;
+                                        }
+                                    }
+                                }
+
+                                if (!foundExtendedTypeConflict)
+                                {
+                                    staticExtensionImplementationsWithoutReturn[staticExtension] = previousStaticExtension.Add(staticExtension);
+                                }
+                            }
+                            else
+                            {
+                                staticExtensionImplementationsWithoutReturn.Add(staticExtension, OneOrMany.Create<MethodSymbol>(staticExtension));
+                            }
+                        }
+
+                        // Does this static extension implementation collide *as a method* with any previously-seen
+                        // non-static-extension-implementation method?
+
+                        if (methodsBySignature.TryGetValue(staticExtension, out var previousMethod))
+                        {
+                            ReportMethodSignatureCollision(diagnostics, staticExtension, previousMethod);
+                        }
+
+                        if (conversionsAsMethods.TryGetValue(staticExtension, out var previousConversion))
+                        {
+                            ReportMethodSignatureCollision(diagnostics, staticExtension, previousConversion);
+                        }
+                    }
                     else if (symbol is MethodSymbol method && method is (SourceMemberMethodSymbol or SourceExtensionImplementationMethodSymbol))
                     {
+                        Debug.Assert(method is not SourceExtensionImplementationMethodSymbol { UnderlyingMethod.IsStatic: true });
+
                         // Does this method collide *as a method* with any previously-seen
                         // conversion?
 
@@ -2128,7 +2209,15 @@ private void CheckMemberNameConflicts(BindingDiagnosticBag diagnostics)
                         // Do not add the method to the set of previously-seen conversions.
 
                         // Does this method collide *as a method* with any previously-seen
-                        // non-conversion method?
+                        // static extension implementation method?
+
+                        if (staticExtensionImplementationsWithoutReturn?.TryGetValue(method, out OneOrMany<MethodSymbol> previousStaticExtension) == true)
+                        {
+                            ReportMethodSignatureCollision(diagnostics, method, previousStaticExtension.First());
+                        }
+
+                        // Does this method collide *as a method* with any previously-seen
+                        // non-conversion or non-static-extension-implementation method?
 
                         if (methodsBySignature.TryGetValue(method, out var previousMethod))
                         {