Do a better job matching properties to implement against existing properties

src/Analyzers/CSharp/Tests/ImplementInterface/ImplementInterfaceTests.cs

@@ -12129,4 +12129,35 @@ class Class : IEnumerator<int>
             }
             """);
     }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/19721")]
+    public async Task TestMatchPropertyAgainstPropertyWithMoreAccessors1()
+    {
+        await TestWithAllCodeStyleOptionsOnAsync(
+            """
+            interface ImmutableView
+            {
+                int Prop1 { get; }
+            }
+            interface MutableView : ImmutableView
+            {
+                new int Prop1 { get; set; }
+            }
+            class Implementation : {|CS0535:{|CS0535:MutableView|}|} { }
+            """,
+            """
+            interface ImmutableView
+            {
+                int Prop1 { get; }
+            }
+            interface MutableView : ImmutableView
+            {
+                new int Prop1 { get; set; }
+            }
+            class Implementation : MutableView
+            {
+                public int Prop1 { get => throw new System.NotImplementedException(); set => throw new System.NotImplementedException(); }
+            }
+            """);
+    }
 }

src/Analyzers/Core/CodeFixes/ImplementInterface/ImplementInterfaceGenerator.cs

@@ -405,22 +405,35 @@ private bool HasMatchingMember(ArrayBuilder<ISymbol> implementedVisibleMembers,
             return implementedVisibleMembers.Any(m => MembersMatch(m, member));
         }
 
-        private bool MembersMatch(ISymbol member1, ISymbol member2)
+        private bool MembersMatch(ISymbol existingMember, ISymbol memberToAdd)
         {
-            if (member1.Kind != member2.Kind)
+            if (existingMember.Kind != memberToAdd.Kind)
                 return false;
 
-            if (member1.DeclaredAccessibility != member2.DeclaredAccessibility ||
-                member1.IsStatic != member2.IsStatic)
+            if (existingMember.DeclaredAccessibility != memberToAdd.DeclaredAccessibility ||
+                existingMember.IsStatic != memberToAdd.IsStatic)
             {
                 return false;
             }
 
-            if (member1.ExplicitInterfaceImplementations().Any() || member2.ExplicitInterfaceImplementations().Any())
+            if (existingMember.ExplicitInterfaceImplementations().Any() || memberToAdd.ExplicitInterfaceImplementations().Any())
                 return false;
 
-            return SignatureComparer.Instance.HaveSameSignatureAndConstraintsAndReturnTypeAndAccessors(
-                member1, member2, IsCaseSensitive);
+            if (!SignatureComparer.Instance.HaveSameSignatureAndConstraintsAndReturnType(existingMember, memberToAdd, IsCaseSensitive))
+                return false;
+
+            if (existingMember is IPropertySymbol existingProperty && memberToAdd is IPropertySymbol propertyToAdd)
+            {
+                // Have to make sure the accessors of the properties are complimentary.  Note: it's ok for the new
+                // property to have a subset of the accessors of the existing property.
+                if (propertyToAdd.GetMethod != null && SignatureComparer.BadPropertyAccessor(propertyToAdd.GetMethod, existingProperty.GetMethod))
+                    return false;
+
+                if (propertyToAdd.SetMethod != null && SignatureComparer.BadPropertyAccessor(propertyToAdd.SetMethod, existingProperty.SetMethod))
+                    return false;
+            }
+
+            return true;
         }
     }
 }

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/SignatureComparer.cs

@@ -62,7 +62,7 @@ public bool HaveSameSignature(IPropertySymbol property1, IPropertySymbol propert
             this.ParameterEquivalenceComparer);
     }
 
-    private static bool BadPropertyAccessor(IMethodSymbol method1, IMethodSymbol method2)
+    public static bool BadPropertyAccessor(IMethodSymbol method1, IMethodSymbol method2)
     {
         return method1 != null &&
             (method2 == null || method2.DeclaredAccessibility != Accessibility.Public);
@@ -137,6 +137,21 @@ public bool HaveSameSignature(
     }
 
     public bool HaveSameSignatureAndConstraintsAndReturnTypeAndAccessors(ISymbol symbol1, ISymbol symbol2, bool caseSensitive)
+    {
+        // NOTE - we're deliberately using reference equality here for speed.
+        if (symbol1 == symbol2)
+            return true;
+
+        if (!HaveSameSignatureAndConstraintsAndReturnType(symbol1, symbol2, caseSensitive))
+            return false;
+
+        if (symbol1 is IPropertySymbol property1 && symbol2 is IPropertySymbol property2)
+            return HaveSameAccessors(property1, property2);
+
+        return true;
+    }
+
+    public bool HaveSameSignatureAndConstraintsAndReturnType(ISymbol symbol1, ISymbol symbol2, bool caseSensitive)
     {
         // NOTE - we're deliberately using reference equality here for speed.
         if (symbol1 == symbol2)
@@ -158,8 +173,7 @@ public bool HaveSameSignatureAndConstraintsAndReturnTypeAndAccessors(ISymbol sym
 
                 return property1.ReturnsByRef == property2.ReturnsByRef &&
                        property1.ReturnsByRefReadonly == property2.ReturnsByRefReadonly &&
-                       this.SignatureTypeEquivalenceComparer.Equals(property1.Type, property2.Type) &&
-                       HaveSameAccessors(property1, property2);
+                       this.SignatureTypeEquivalenceComparer.Equals(property1.Type, property2.Type);
             case SymbolKind.Event:
                 var ev1 = (IEventSymbol)symbol1;
                 var ev2 = (IEventSymbol)symbol2;