Extensions: Ignore ref kind of extension parameter for static members in betterness (#79885)

Author: jcouv

src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs

@@ -2566,11 +2566,11 @@ private BetterResult BetterFunctionMember<TMember>(
 
             // Returns the parameter type (considering params).
             static TypeSymbol getParameterTypeAndRefKind(int i, MemberAnalysisResult memberResolutionResult, ImmutableArray<ParameterSymbol> parameters,
-                TypeWithAnnotations paramsElementTypeOpt, TMember member, out RefKind parameter1RefKind)
+                TypeWithAnnotations paramsElementTypeOpt, TMember member, out RefKind parameterRefKind)
             {
                 ParameterSymbol parameter = getParameterOrExtensionParameter(i, memberResolutionResult, parameters, member);
 
-                parameter1RefKind = parameter.RefKind;
+                parameterRefKind = GetParameterBetternessRefKind(parameter, member);
 
                 var type = parameter.Type;
                 if (memberResolutionResult.Kind == MemberResolutionKind.ApplicableInExpandedForm &&
@@ -2631,7 +2631,10 @@ static BetterResult preferValOverInOrRefInterpolatedHandlerParameters(
                             Debug.Assert(!isInterpolatedStringHandlerConversion || arguments[i] is BoundUnconvertedInterpolatedString or BoundBinaryOperator { IsUnconvertedInterpolatedStringAddition: true });
                         }
 
-                        if (p1.RefKind == RefKind.None && isAcceptableRefMismatch(p2.RefKind, isInterpolatedStringHandlerConversion))
+                        RefKind refKind1 = GetParameterBetternessRefKind(p1, m1.Member);
+                        RefKind refKind2 = GetParameterBetternessRefKind(p2, m2.Member);
+
+                        if (refKind1 == RefKind.None && isAcceptableRefMismatch(refKind2, isInterpolatedStringHandlerConversion))
                         {
                             if (valOverInOrRefInterpolatedHandlerPreference == BetterResult.Right)
                             {
@@ -2642,7 +2645,7 @@ static BetterResult preferValOverInOrRefInterpolatedHandlerParameters(
                                 valOverInOrRefInterpolatedHandlerPreference = BetterResult.Left;
                             }
                         }
-                        else if (p2.RefKind == RefKind.None && isAcceptableRefMismatch(p1.RefKind, isInterpolatedStringHandlerConversion))
+                        else if (refKind2 == RefKind.None && isAcceptableRefMismatch(refKind1, isInterpolatedStringHandlerConversion))
                         {
                             if (valOverInOrRefInterpolatedHandlerPreference == BetterResult.Left)
                             {
@@ -2670,6 +2673,16 @@ static bool isAcceptableRefMismatch(RefKind refKind, bool isInterpolatedStringHa
             }
         }
 
+        private static RefKind GetParameterBetternessRefKind<TMember>(ParameterSymbol parameter, TMember member) where TMember : Symbol
+        {
+            // For static extension members, the ref kind of the extension parameter shouldn't affect betterness.
+            bool isExtensionParameterOfStaticExtensionMember = parameter is { ContainingSymbol: TypeSymbol { IsExtension: true, ExtensionParameter: var extensionParameter } }
+                && member.IsStatic
+                && object.ReferenceEquals(parameter, extensionParameter);
+
+            return isExtensionParameterOfStaticExtensionMember ? RefKind.None : parameter.RefKind;
+        }
+
         /// <summary>
         /// Returns true if the overload required a function type conversion to infer
         /// generic method type arguments or to convert to parameter types.

src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionOperatorsTests.cs

@@ -5,6 +5,7 @@
 
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
@@ -27578,5 +27579,76 @@ static void Main()
                 Diagnostic(ErrorCode.ERR_BadBinaryOps, "x += 1").WithArguments("+=", "C1", "int").WithLocation(7, 9)
                 );
         }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/79171")]
+        public void RemoveWorseMembers_01()
+        {
+            // by-value vs. in extension parameter, static operator
+            var src = """
+_ = new S() + new S();
+
+struct S { }
+
+static class E1
+{
+    extension(S)
+    {
+        public static S operator +(S s1, S s2) => throw null;
+    }
+}
+
+static class E2
+{
+    extension(in S s)
+    {
+        public static S operator +(S s1, S s2) => throw null;
+    }
+}
+""";
+            var comp = CreateCompilation(src);
+            comp.VerifyEmitDiagnostics(
+                // (1,5): error CS0034: Operator '+' is ambiguous on operands of type 'S' and 'S'
+                // _ = new S() + new S();
+                Diagnostic(ErrorCode.ERR_AmbigBinaryOps, "new S() + new S()").WithArguments("+", "S", "S").WithLocation(1, 5));
+
+            var tree = comp.SyntaxTrees.First();
+            var model = comp.GetSemanticModel(tree);
+            var binary = GetSyntax<BinaryExpressionSyntax>(tree, "new S() + new S()");
+            Assert.Null(model.GetSymbolInfo(binary).Symbol);
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/79171")]
+        public void RemoveWorseMembers_02()
+        {
+            // by-value vs. in parameter, static operator
+            var src = """
+_ = new S() + new S();
+
+struct S { }
+
+static class E1
+{
+    extension(S)
+    {
+        public static S operator +(S s1, S s2) => throw null;
+    }
+}
+
+static class E2
+{
+    extension(S)
+    {
+        public static S operator +(in S s1, S s2) => throw null;
+    }
+}
+""";
+            var comp = CreateCompilation(src);
+            comp.VerifyEmitDiagnostics();
+
+            var tree = comp.SyntaxTrees.First();
+            var model = comp.GetSemanticModel(tree);
+            var binary = GetSyntax<BinaryExpressionSyntax>(tree, "new S() + new S()");
+            AssertEx.Equal("S E1.<G>$3B24C9A1A6673CA92CA71905DDEE0A6C.op_Addition(S s1, S s2)", model.GetSymbolInfo(binary).Symbol.ToTestDisplayString());
+        }
     }
 }