Move OverrideAllMembersCodeFix to CodeFix assembly to avoid csc error

This code fix should only load in our own workspace, since csc does not contain the
required dependencies for it to load properly. This was causing transient build errors
when csc.exe would try to inspect the types via MEF and fail in the static initialization
of the RoslynInternals class which even if not used since the code fix was not exported,
was nevertheless initialized statically when reflected by the MEF composition.

By moving it to the CodeFix assembly, we also make it work transparently like all other
code fixers, which are referenced just by name. We were already doing that from the
C# and VB scaffold document processors, so no changes were necessary there.

src/Moq/Moq.Sdk.Tests/Moq.Sdk.Tests.csproj

@@ -16,6 +16,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\Stunts\Stunts.CodeFix\Stunts.CodeFix.csproj" />
     <ProjectReference Include="..\Moq.Sdk\Moq.Sdk.csproj" />
     <ProjectReference Include="..\..\Stunts\Stunts\Stunts.csproj" />
     <ProjectReference Include="..\..\Stunts\Stunts.Sdk\Stunts.Sdk.csproj" />

src/Moq/Moq.Tests/LegacyTests.cs

@@ -0,0 +1,28 @@
+using System;
+using Xunit;
+
+namespace Moq.Tests
+{
+    public class LegacyTests
+    {
+        [Fact]
+        public void AsInterface()
+        {
+            var sp = new Mock<IServiceProvider>();
+
+            sp.Setup(x => x.GetService(typeof(IDisposable))).Returns(Mock.Of<IDisposable>());
+
+            sp.As<IDisposable>()
+                .Setup(x => x.Dispose())
+                .Callback(() => Assert.False(true, "Callback"));
+
+            Assert.NotNull(sp.Object.GetService(typeof(IDisposable)));
+
+            var disposable = sp.Object as IDisposable;
+
+            Assert.NotNull(disposable);
+
+            disposable.Dispose();
+        }
+    }
+}

src/Stunts/Stunts.CodeFix/OverrideAllMembersCodeFix.cs

@@ -0,0 +1,69 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Editing;
+
+namespace Stunts
+{
+    /// <summary>
+    /// Implements the codefix for overriding all members in a class 
+    /// using <see cref="RoslynInternals.OverrideAsync"/>.
+    /// </summary>
+    [ExportCodeFixProvider(LanguageNames.CSharp, new[] { LanguageNames.VisualBasic }, Name = nameof(OverrideAllMembersCodeFix))]
+    class OverrideAllMembersCodeFix : CodeFixProvider
+    {
+        public sealed override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create(OverridableMembersAnalyzer.DiagnosticId);
+
+        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
+            var diagnostic = context.Diagnostics.FirstOrDefault(d => FixableDiagnosticIds.Contains(d.Id));
+            if (diagnostic == null)
+                return;
+
+            var sourceToken = root.FindToken(diagnostic.Location.SourceSpan.Start);
+
+            // Find the invocation identified by the diagnostic.
+            var type =
+                (SyntaxNode)sourceToken.Parent.AncestorsAndSelf().OfType<Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax>().FirstOrDefault() ??
+                (SyntaxNode)sourceToken.Parent.AncestorsAndSelf().OfType<Microsoft.CodeAnalysis.VisualBasic.Syntax.ClassBlockSyntax>().FirstOrDefault();
+
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    title: "Override All Members",
+                    createChangedSolution: c => OverrideAllMembersAsync(context.Document, type, c),
+                    equivalenceKey: nameof(OverrideAllMembersCodeFix)),
+                diagnostic);
+        }
+
+        async Task<Solution> OverrideAllMembersAsync(Document document, SyntaxNode type, CancellationToken cancellationToken)
+        {
+            var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
+            var symbol = semanticModel.GetDeclaredSymbol(type) as INamedTypeSymbol;
+            if (symbol == null)
+                return document.Project.Solution;
+
+            var overridables = RoslynInternals.GetOverridableMembers(symbol, cancellationToken);
+
+            if (type.Language == LanguageNames.VisualBasic)
+                overridables = overridables
+                    .Where(x => x.MetadataName != WellKnownMemberNames.DestructorName)
+                    // VB doesn't support overriding events (yet). See https://github.com/dotnet/vblang/issues/63
+                    .Where(x => x.Kind != SymbolKind.Event)
+                    .ToImmutableArray();            
+
+            var generator = SyntaxGenerator.GetGenerator(document);
+            var memberTasks = overridables.Select(
+                m => RoslynInternals.OverrideAsync(generator, m, symbol, document, cancellationToken: cancellationToken));
+
+            var members = await Task.WhenAll(memberTasks);
+            var newDoc = await RoslynInternals.AddMemberDeclarationsAsync(document.Project.Solution, symbol, members, cancellationToken);
+
+            return newDoc.Project.Solution;
+        }
+    }
+}

src/Stunts/Stunts.CodeFix/Stunts.CodeFix.csproj

@@ -15,6 +15,10 @@
       <AdditionalProperties>PrimaryOutputKind=$(PrimaryOutputKind);IncludeApi=false</AdditionalProperties>
     </ProjectReference>
   </ItemDefinitionGroup>
+
+  <ItemGroup>
+    <Compile Include="..\Stunts.Sdk\RoslynInternals.cs" Link="RoslynInternals.cs" />
+  </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\Stunts\Stunts.csproj" />

src/Stunts/Stunts.CodeFix/Stunts.props

@@ -23,5 +23,4 @@
     </Compile>
   </ItemGroup>
 
-
 </Project>

src/Stunts/Stunts.Sdk/DocumentExtensions.cs

@@ -143,8 +143,7 @@ await provider.RegisterCodeFixesAsync(
         // Debug view of all available providers and their metadata
         // document.Project.Solution.Workspace.Services.HostServices.GetExports<CodeFixProvider, IDictionary<string, object>>().OrderBy(x => x.Metadata["Name"]?.ToString()).Select(x => $"{x.Metadata["Name"]}: {string.Join(", ", (string[])x.Metadata["Languages"])}"  ).ToList()
         static CodeFixProvider GetCodeFixProvider(Document document, string codeFixName)
-            => codeFixName == nameof(OverrideAllMembersCodeFix) ? new OverrideAllMembersCodeFix() :
-                document.Project.Solution.Workspace.Services.HostServices
+            => document.Project.Solution.Workspace.Services.HostServices
                     .GetExports<CodeFixProvider, IDictionary<string, object>>()
                     .Where(x =>
                         x.Metadata.ContainsKey("Languages") && x.Metadata.ContainsKey("Name") &&

src/Stunts/Stunts.Tests/DynamicStunt.cs

@@ -9,9 +9,10 @@
 
 namespace Stunts.Tests
 {
-    class DynamicStunt
+    class DynamicStunt : IDisposable
     {
         StuntGenerator generator = new StuntGenerator();
+        Workspace workspace;
         Project project;
         readonly string language;
 
@@ -53,8 +54,8 @@ async Task<Project> GetProjectAsync()
         {
             if (project == null)
             {
-                var (workspace, project) = CreateWorkspaceAndProject(language);
-                this.project = project.AddAnalyzerReference(new AnalyzerImageReference(new DiagnosticAnalyzer[] { new OverridableMembersAnalyzer() }.ToImmutableArray()));
+                (workspace, project) = CreateWorkspaceAndProject(language);
+                project = project.AddAnalyzerReference(new AnalyzerImageReference(new DiagnosticAnalyzer[] { new OverridableMembersAnalyzer() }.ToImmutableArray()));
                 var compilation = await project.GetCompilationAsync(TimeoutToken(5));
 
                 Assert.False(compilation.GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error),
@@ -73,5 +74,7 @@ static ITypeSymbol GetSymbolFromType(Compilation compilation, Type type)
                 .GetTypeByMetadataName(type.GetGenericTypeDefinition().FullName)
                 .Construct(type.GenericTypeArguments.Select(t => GetSymbolFromType(compilation, t)).ToArray());
         }
+
+        public void Dispose() => workspace.Dispose();
     }
 }

src/Stunts/Stunts.Tests/Stunts.Tests.csproj

@@ -38,12 +38,10 @@
   <ItemGroup>
     <Compile Include="..\..\Moq\Moq.Sdk\DefaultValueBehavior.cs" Link="DefaultValueBehavior.cs" />
     <Compile Include="..\..\Moq\Moq.Sdk\DefaultValueProvider.cs" Link="DefaultValueProvider.cs" />
-    <None Include="..\Stunts.Sdk\RoslynInternals.cs" Link="RoslynInternals.cs">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\Stunts.CodeFix\Stunts.CodeFix.csproj" />
     <ProjectReference Include="..\Stunts\Stunts.csproj" />
     <ProjectReference Include="..\Stunts.Sdk\Stunts.Sdk.csproj" />
     <ProjectReference Include="..\..\Samples\Sample\Sample.csproj" />

src/Testing/TestHelpers.cs

@@ -14,15 +14,17 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.VisualBasic;
+using Stunts;
 using Xunit;
 
 static partial class TestHelpers
 {
     public static (AdhocWorkspace workspace, Project project) CreateWorkspaceAndProject(string language, string assemblyName = "Code", bool includeStuntApi = true, bool includeMockApi = false)
     {
-        var workspace = new AdhocWorkspace();
+        var workspace = new AdhocWorkspace(MefHostServices.Create(MefHostServices.DefaultAssemblies.Concat(new[] { typeof(StuntCodeFixProvider).Assembly })));
         var projectInfo = CreateProjectInfo(language, assemblyName, includeStuntApi, includeMockApi);
         var project = workspace.AddProject(projectInfo);
 

src/build/Settings.props

@@ -56,6 +56,12 @@
     <None Remove="*.binlog" />
   </ItemGroup>
 
+  <ItemDefinitionGroup>
+    <PackageReference>
+      <GeneratePathProperty>true</GeneratePathProperty>
+    </PackageReference>
+  </ItemDefinitionGroup>
+
   <!-- IsTestProject is set by xunit  -->
   <Import Project="Settings.Tests.props" Condition="'$(IsTestProject)' == 'true'" />