Enhance explicit interface implementation completion provider

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

@@ -4663,81 +4663,87 @@ public async Task TestOptionalDateTime1()
         await new VerifyCS.Test
         {
             TestCode = """
-            using System;
-            using System.Runtime.CompilerServices;
-            using System.Runtime.InteropServices;
+                using System;
+                using System.Runtime.CompilerServices;
+                using System.Runtime.InteropServices;
 
-            interface IGoo
-            {
-                void Goo([Optional][DateTimeConstant(100)] DateTime x);
-            }
+                interface IGoo
+                {
+                    void Goo([Optional][DateTimeConstant(100)] DateTime x);
+                }
 
-            public class C : {|CS0535:IGoo|}
-            {
-            }
-            """,
+                public class C : {|CS0535:IGoo|}
+                {
+                }
+                """,
             FixedCode = """
-            using System;
-            using System.Runtime.CompilerServices;
-            using System.Runtime.InteropServices;
+                using System;
+                using System.Runtime.CompilerServices;
+                using System.Runtime.InteropServices;
 
-            interface IGoo
-            {
-                void Goo([Optional][DateTimeConstant(100)] DateTime x);
-            }
+                interface IGoo
+                {
+                    void Goo([Optional][DateTimeConstant(100)] DateTime x);
+                }
 
-            public class C : IGoo
-            {
-                public void Goo([DateTimeConstant(100), Optional] DateTime x)
+                public class C : IGoo
                 {
-                    throw new NotImplementedException();
+                    public void Goo([DateTimeConstant(100), Optional] DateTime x)
+                    {
+                        throw new NotImplementedException();
+                    }
                 }
-            }
-            """,
+                """,
             Options = { AllOptionsOff },
 
-            // 🐛 one value is generated with 0L instead of 0
+            // 🐛 one value is generated with 100L instead of 100L
             CodeActionValidationMode = CodeActionValidationMode.None,
         }.RunAsync();
     }
 
     [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545476")]
     public async Task TestOptionalDateTime2()
     {
-        await TestWithAllCodeStyleOptionsOffAsync(
-            """
-            using System;
-            using System.Runtime.CompilerServices;
-            using System.Runtime.InteropServices;
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                using System;
+                using System.Runtime.CompilerServices;
+                using System.Runtime.InteropServices;
 
-            interface IGoo
-            {
-                void Goo([Optional][DateTimeConstant(100)] DateTime x);
-            }
+                interface IGoo
+                {
+                    void Goo([Optional][DateTimeConstant(100)] DateTime x);
+                }
 
-            public class C : {|CS0535:IGoo|}
-            {
-            }
-            """,
-            """
-            using System;
-            using System.Runtime.CompilerServices;
-            using System.Runtime.InteropServices;
+                public class C : {|CS0535:IGoo|}
+                {
+                }
+                """,
+            FixedCode = """
+                using System;
+                using System.Runtime.CompilerServices;
+                using System.Runtime.InteropServices;
 
-            interface IGoo
-            {
-                void Goo([Optional][DateTimeConstant(100)] DateTime x);
-            }
+                interface IGoo
+                {
+                    void Goo([Optional][DateTimeConstant(100)] DateTime x);
+                }
 
-            public class C : IGoo
-            {
-                void IGoo.Goo(DateTime x)
+                public class C : IGoo
                 {
-                    throw new NotImplementedException();
+                    void IGoo.Goo([DateTimeConstant(100), Optional] DateTime x)
+                    {
+                        throw new NotImplementedException();
+                    }
                 }
-            }
-            """,
-codeAction: ("True;False;False:global::IGoo;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
+                """,
+            Options = { AllOptionsOff },
+
+            CodeActionEquivalenceKey = "True;False;False:global::IGoo;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            // 🐛 one value is generated with 0L instead of 0
+            CodeActionValidationMode = CodeActionValidationMode.None,
+        }.RunAsync();
     }
 
     [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545477")]
@@ -4813,12 +4819,12 @@ interface IGoo
 
             public class C : IGoo
             {
-                void IGoo.Goo1(object x)
+                void IGoo.Goo1([IUnknownConstant, Optional] object x)
                 {
                     throw new System.NotImplementedException();
                 }
 
-                void IGoo.Goo2(object x)
+                void IGoo.Goo2([IDispatchConstant, Optional] object x)
                 {
                     throw new System.NotImplementedException();
                 }
@@ -6726,7 +6732,8 @@ interface I
 
             class C : I
             {
-                bool I.Goo(bool x)
+                [return: MarshalAs(UnmanagedType.U1)]
+                bool I.Goo([MarshalAs(UnmanagedType.U1)] bool x)
                 {
                     throw new System.NotImplementedException();
                 }
@@ -7622,6 +7629,29 @@ public List<UU> M<TT, UU>(Dictionary<TT, List<UU>> a, TT b, UU c) where UU : TT
     [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/994328")]
     public async Task TestDisposePatternWhenAdditionalUsingsAreIntroduced2()
     {
+        const string equatableParameter =
+#if NET9_0_OR_GREATER
+            "[AllowNull] int other"
+#else
+            "int other"
+#endif
+            ;
+
+        const string resultUsings =
+#if NET9_0_OR_GREATER
+            """
+            using System;
+            using System.Collections.Generic;
+            using System.Diagnostics.CodeAnalysis;
+            """
+#else
+            """
+            using System;
+            using System.Collections.Generic;
+            """
+#endif
+            ;
+
         await TestWithAllCodeStyleOptionsOffAsync(
             """
             interface I<T, U> : System.IDisposable, System.IEquatable<int> where U : T
@@ -7639,8 +7669,7 @@ partial class C
             }
             """,
             $$"""
-            using System;
-            using System.Collections.Generic;
+            {{resultUsings}}
 
             interface I<T, U> : System.IDisposable, System.IEquatable<int> where U : T
             {
@@ -7652,7 +7681,7 @@ partial class C : I<System.Exception, System.AggregateException>, System.IDispos
             {
                 private bool disposedValue;
 
-                bool IEquatable<int>.Equals(int other)
+                bool IEquatable<int>.Equals({{equatableParameter}})
                 {
                     throw new NotImplementedException();
                 }
@@ -11538,12 +11567,12 @@ class C3 : I1<C3>
                     throw new System.NotImplementedException();
                 }
 
-                public static explicit operator checked string(C3 x)
+                static explicit I1<C3>.operator checked string(C3 x)
                 {
                     throw new System.NotImplementedException();
                 }
 
-                public static explicit operator string(C3 x)
+                static explicit I1<C3>.operator string(C3 x)
                 {
                     throw new System.NotImplementedException();
                 }

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

@@ -2,7 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editing;
@@ -11,6 +15,7 @@
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.ImplementInterface;
 
@@ -43,7 +48,6 @@ public async Task<Document> ImplementInterfaceAsync(
             if (state == null)
                 return document;
 
-            // TODO: https://github.com/dotnet/roslyn/issues/60990
             // While implementing just one default action, like in the case of pressing enter after interface name in VB,
             // choose to implement with the dispose pattern as that's the Dev12 behavior.
             var implementDisposePattern = ShouldImplementDisposePattern(model.Compilation, state, explicitly: false);
@@ -94,4 +98,59 @@ public async Task<Document> ImplementInterfaceAsync(
             this, document, info, options, configuration);
         return await generator.ImplementInterfaceAsync(cancellationToken).ConfigureAwait(false);
     }
+
+    public async Task<ISymbol> ExplicitlyImplementSingleInterfaceMemberAsync(
+        Document document,
+        IImplementInterfaceInfo info,
+        ISymbol member,
+        ImplementTypeOptions options,
+        CancellationToken cancellationToken)
+    {
+        var configuration = new ImplementInterfaceConfiguration()
+        {
+            Abstractly = false,
+            Explicitly = true,
+            OnlyRemaining = false,
+            ImplementDisposePattern = false,
+            ThroughMember = null,
+        };
+        var generator = new ImplementInterfaceGenerator(
+            this, document, info, options, configuration);
+        var implementedMembers = await generator.GenerateExplicitlyImplementedMembersAsync(member, options.PropertyGenerationBehavior, cancellationToken).ConfigureAwait(false);
+        cancellationToken.ThrowIfCancellationRequested();
+
+        var singleImplemented = implementedMembers[0];
+        Contract.ThrowIfNull(singleImplemented);
+
+        // Since non-indexer properties are the only symbols that get their implementing accessor symbols returned,
+        // we have to process the created symbols and reduce to the single property wherein the accessors are contained
+        if (member is IPropertySymbol { IsIndexer: false })
+        {
+            IPropertySymbol? commonContainer = null;
+            foreach (var implementedMember in implementedMembers)
+            {
+                if (implementedMember is IPropertySymbol implementedProperty)
+                {
+                    commonContainer ??= implementedProperty;
+                    Contract.ThrowIfFalse(commonContainer == implementedProperty, "We should have a common property implemented");
+                }
+                else
+                {
+                    Contract.ThrowIfNull(implementedMember);
+                    var containingProperty = implementedMember!.ContainingSymbol as IPropertySymbol;
+                    Contract.ThrowIfNull(containingProperty);
+                    commonContainer ??= containingProperty;
+                    Contract.ThrowIfFalse(commonContainer == containingProperty, "We should have a common property implemented");
+                }
+            }
+            Contract.ThrowIfNull(commonContainer);
+            singleImplemented = commonContainer;
+        }
+        else
+        {
+            Contract.ThrowIfFalse(implementedMembers.Length == 1, "We missed another case that may return multiple symbols");
+        }
+
+        return singleImplemented;
+    }
 }

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

@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Collections.Immutable;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
@@ -30,4 +30,11 @@ Task<Document> ImplementInterfaceAsync(
         ImplementTypeOptions options,
         ImplementInterfaceConfiguration configuration,
         CancellationToken cancellationToken);
+
+    Task<ISymbol> ExplicitlyImplementSingleInterfaceMemberAsync(
+        Document document,
+        IImplementInterfaceInfo info,
+        ISymbol member,
+        ImplementTypeOptions options,
+        CancellationToken cancellationToken);
 }

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

@@ -274,6 +274,20 @@ private static bool IsUnexpressibleTypeParameter(
             return condition1 || condition2 || condition3;
         }
 
+        public async Task<ImmutableArray<ISymbol?>> GenerateExplicitlyImplementedMembersAsync(
+            ISymbol member,
+            ImplementTypePropertyGenerationBehavior propertyGenerationBehavior,
+            CancellationToken cancellationToken)
+        {
+            var compilation = await Document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
+            var syntaxFacts = Document.GetRequiredLanguageService<ISyntaxFactsService>();
+            var addUnsafe = member.RequiresUnsafeModifier() && !syntaxFacts.IsUnsafeContext(State.InterfaceNode);
+            return GenerateMembers(
+                compilation, member, memberName: member.Name, generateInvisibly: true,
+                generateAbstractly: false, addNew: false, addUnsafe, propertyGenerationBehavior)
+                    .ToImmutableArray();
+        }
+
         private IEnumerable<ISymbol?> GenerateMembers(
             Compilation compilation,
             ISymbol member,