Fix layering of Implement-Interface code-fixer vs language service

src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceCodeFixProvider.cs

@@ -59,14 +59,16 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         }
     }
 
-    private IEnumerable<IImplementInterfaceGenerator> GetGenerators(
+    private async IEnumerable<IImplementInterfaceGenerator> GetGenerators(
         Document document, ImplementTypeGenerationOptions options, IImplementInterfaceInfo? state, CancellationToken cancellationToken)
     {
         if (state == null)
         {
             yield break;
         }
 
+        var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
+
         if (state.MembersWithoutExplicitOrImplicitImplementationWhichCanBeImplicitlyImplemented.Length > 0)
         {
             var totalMemberCount = 0;
@@ -92,7 +94,7 @@ private IEnumerable<IImplementInterfaceGenerator> GetGenerators(
                 yield return ImplementInterfaceGenerator.CreateImplement(this, document, options, state);
             }
 
-            if (ShouldImplementDisposePattern(state, explicitly: false))
+            if (ShouldImplementDisposePattern(compilation, state, explicitly: false))
             {
                 yield return ImplementInterfaceWithDisposePatternGenerator.CreateImplementWithDisposePattern(this, document, options, state);
             }

src/Features/Core/Portable/ImplementInterface/IImplementInterfaceService.cs

@@ -2,6 +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.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
@@ -20,6 +21,10 @@ internal interface IImplementInterfaceGenerator
 internal interface IImplementInterfaceInfo
 {
     INamedTypeSymbol ClassOrStructType { get; }
+
+    ImmutableArray<(INamedTypeSymbol type, ImmutableArray<ISymbol> members)> MembersWithoutExplicitOrImplicitImplementationWhichCanBeImplicitlyImplemented { get; }
+    ImmutableArray<(INamedTypeSymbol type, ImmutableArray<ISymbol> members)> MembersWithoutExplicitOrImplicitImplementation { get; }
+    ImmutableArray<(INamedTypeSymbol type, ImmutableArray<ISymbol> members)> MembersWithoutExplicitImplementation { get; }
 }
 
 internal readonly struct ImplementInterfaceOptions

src/Features/Core/Portable/ImplementInterface/ImplementHelpers.cs

@@ -246,14 +246,14 @@ private static bool IsTypeLessAccessibleThanOtherType(ITypeSymbol? first, INamed
         return false;
     }
 
-    private static bool ShouldImplementDisposePattern(Compilation compilation, IImplementInterfaceInfo state, bool explicitly)
+    public static bool ShouldImplementDisposePattern(Compilation compilation, IImplementInterfaceInfo state, bool explicitly)
     {
         // Dispose pattern should be implemented only if -
         // 1. An interface named 'System.IDisposable' is unimplemented.
         // 2. This interface has one and only one member - a non-generic method named 'Dispose' that takes no arguments and returns 'void'.
-        // 3. The implementing type is a class that does not already declare any conflicting members named 'disposedValue' or 'Dispose'
-        //    (because we will be generating a 'disposedValue' field and a couple of methods named 'Dispose' as part of implementing
-        //    the dispose pattern).
+        // 3. The implementing type is a class that does not already declare any conflicting members named
+        //    'disposedValue' or 'Dispose' (because we will be generating a 'disposedValue' field and a couple of
+        //    methods named 'Dispose' as part of implementing the dispose pattern).
         if (state.ClassOrStructType.TypeKind != TypeKind.Class)
             return false;