Fix checked/unchecked pair matching for extension unary operators during consumption (#78538)

Author: AlekseyTs

src/Compilers/CSharp/Portable/Binder/Semantics/Operators/UnaryOperatorOverloadResolution.cs

@@ -245,22 +245,36 @@ private PairedExtensionUnaryOperatorSignatureComparer() { }
 
             public bool Equals(UnaryOperatorSignature x, UnaryOperatorSignature y)
             {
-                return x.Method.OriginalDefinition.ContainingType.ContainingType == (object)x.Method.OriginalDefinition.ContainingType.ContainingType &&
-                       new SourceMemberContainerTypeSymbol.ExtensionGroupingKey(x.Method.OriginalDefinition.ContainingType).Equals(
-                           new SourceMemberContainerTypeSymbol.ExtensionGroupingKey(y.Method.OriginalDefinition.ContainingType)) &&
-                       SourceMemberContainerTypeSymbol.DoOperatorsPair(x.Method.OriginalDefinition, y.Method.OriginalDefinition);
+                if (x.Method.OriginalDefinition.ContainingType.ContainingType != (object)x.Method.OriginalDefinition.ContainingType.ContainingType)
+                {
+                    return false;
+                }
+
+                var xGroupingKey = new SourceMemberContainerTypeSymbol.ExtensionGroupingKey(x.Method.OriginalDefinition.ContainingType);
+                var yGroupingKey = new SourceMemberContainerTypeSymbol.ExtensionGroupingKey(y.Method.OriginalDefinition.ContainingType);
+
+                if (!xGroupingKey.Equals(yGroupingKey))
+                {
+                    return false;
+                }
+
+                return SourceMemberContainerTypeSymbol.DoOperatorsPair(
+                           x.Method.OriginalDefinition.AsMember(xGroupingKey.NormalizedExtension),
+                           y.Method.OriginalDefinition.AsMember(yGroupingKey.NormalizedExtension));
             }
 
             public int GetHashCode(UnaryOperatorSignature op)
             {
                 var typeComparer = Symbols.SymbolEqualityComparer.AllIgnoreOptions;
 
                 int result = typeComparer.GetHashCode(op.Method.OriginalDefinition.ContainingType.ContainingType);
-                result = Hash.Combine(result, new SourceMemberContainerTypeSymbol.ExtensionGroupingKey(op.Method.OriginalDefinition.ContainingType).GetHashCode());
 
-                foreach (var typeWithAnnotations in op.Method.OriginalDefinition.ParameterTypesWithAnnotations)
+                var groupingKey = new SourceMemberContainerTypeSymbol.ExtensionGroupingKey(op.Method.OriginalDefinition.ContainingType);
+                result = Hash.Combine(result, groupingKey.GetHashCode());
+
+                foreach (var parameter in op.Method.OriginalDefinition.AsMember(groupingKey.NormalizedExtension).Parameters)
                 {
-                    result = Hash.Combine(result, typeComparer.GetHashCode(typeWithAnnotations.Type));
+                    result = Hash.Combine(result, typeComparer.GetHashCode(parameter.Type));
                 }
 
                 return result;

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

@@ -2482,25 +2482,38 @@ static ImmutableArray<Symbol> concatMembers(ImmutableArray<Symbol> existingMembe
 
         internal readonly struct ExtensionGroupingKey : IEquatable<ExtensionGroupingKey>
         {
-            public readonly int ExtensionArity;
-            public readonly TypeSymbol ReceiverType;
+            public readonly NamedTypeSymbol NormalizedExtension;
 
             public ExtensionGroupingKey(NamedTypeSymbol extension)
             {
-                ExtensionArity = extension.Arity;
-
                 if (extension.Arity != 0)
                 {
                     extension = extension.Construct(IndexedTypeParameterSymbol.Take(extension.Arity));
                 }
 
-                if (extension.ExtensionParameter is { } receiverParameter)
+                NormalizedExtension = extension;
+            }
+
+            private readonly int ExtensionArity
+            {
+                get
                 {
-                    ReceiverType = receiverParameter.Type;
+                    return NormalizedExtension.Arity;
                 }
-                else
+            }
+
+            private readonly TypeSymbol ReceiverType
+            {
+                get
                 {
-                    ReceiverType = ErrorTypeSymbol.UnknownResultType;
+                    if (NormalizedExtension.ExtensionParameter is { } receiverParameter)
+                    {
+                        return receiverParameter.Type;
+                    }
+                    else
+                    {
+                        return ErrorTypeSymbol.UnknownResultType;
+                    }
                 }
             }
 

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

@@ -1770,6 +1770,51 @@ static void Main()
                 );
         }
 
+        [Fact]
+        public void Unary_034_Consumption_Checked_Generic()
+        {
+            var src = $$$"""
+public static class Extensions1
+{
+    extension<T1>(C1<T1>)
+    {
+        public static C1<T1> operator -(C1<T1> x)
+        {
+            System.Console.Write("regular");
+            return x;
+        }
+    }
+    extension<T2>(C1<T2>)
+    {
+        public static C1<T2> operator checked -(C1<T2> x)
+        {
+            System.Console.Write("checked");
+            return x;
+        }
+    }
+}
+
+public class C1<T>;
+
+class Program
+{
+    static void Main()
+    {
+        var c1 = new C1<int>();
+        _ = -c1;
+
+        checked
+        {
+            _ = -c1;
+        }
+    }
+}
+""";
+
+            var comp = CreateCompilation(src, options: TestOptions.DebugExe);
+            CompileAndVerify(comp, expectedOutput: "regularchecked").VerifyDiagnostics();
+        }
+
         [Theory]
         [CombinatorialData]
         public void Increment_001_Declaration([CombinatorialValues("++", "--")] string op)