Codeactions with options/ui.

src/OmniSharp.Host/WorkspaceInitializer.cs

@@ -26,7 +26,7 @@ public static void Initialize(IServiceProvider serviceProvider, CompositionHost
             var projectEventForwarder = compositionHost.GetExport<ProjectEventForwarder>();
             projectEventForwarder.Initialize();
             var projectSystems = compositionHost.GetExports<IProjectSystem>();
-            
+
             foreach (var projectSystem in projectSystems)
             {
                 try

src/OmniSharp.Roslyn.CSharp/Services/Refactoring/V2/BaseCodeActionService.cs

@@ -77,13 +77,19 @@ protected async Task<IEnumerable<AvailableCodeAction>> GetAvailableCodeActions(I
             await CollectCodeFixesActions(document, span, codeActions);
             await CollectRefactoringActions(document, span, codeActions);
 
-            // Be sure to filter out any code actions that inherit from CodeActionWithOptions.
-            // This isn't a great solution and might need changing later, but every Roslyn code action
-            // derived from this type tries to display a dialog. For now, this is a reasonable solution.
-            var availableActions = ConvertToAvailableCodeAction(codeActions)
-                .Where(a => !a.CodeAction.GetType().GetTypeInfo().IsSubclassOf(typeof(CodeActionWithOptions)));
+            var availableActions = ConvertToAvailableCodeAction(codeActions);
 
-            return availableActions;
+            return FilterBlacklistedCodeActions(availableActions);
+        }
+
+        private static IEnumerable<AvailableCodeAction> FilterBlacklistedCodeActions(IEnumerable<AvailableCodeAction> codeActions)
+        {
+            // Most of actions with UI works fine with defaults, however there's few exceptions:
+            return codeActions.Where(x =>
+                x.CodeAction.Title != "Generate new type..." &&         // Blacklisted because doesn't give additional value over non UI generate type (when defaults used.)
+                x.CodeAction.Title != "Change signature..." &&          // Blacklisted because cannot be used without proper UI.
+                x.CodeAction.Title != "Pull members up to base type..." // Blacklisted because doesn't give additional value over non UI generate type (when defaults used.)
+            );
         }
 
         private TextSpan GetTextSpan(ICodeActionRequest request, SourceText sourceText)

src/OmniSharp.Roslyn/HostServicesAggregator.cs

@@ -52,6 +52,8 @@ public HostServicesAggregator(
                 }
             }
 
+            builder.Add(typeof(PickMemberWorkspaceService).Assembly);
+
             _assemblies = builder.ToImmutableArray();
         }
 

src/OmniSharp.Roslyn/OmniSharp.Roslyn.csproj

@@ -16,6 +16,7 @@
     <PackageReference Include="Microsoft.Extensions.Caching.Memory" />
     <PackageReference Include="Microsoft.CodeAnalysis.Common" />
     <PackageReference Include="System.ComponentModel.Composition" />
+    <PackageReference Include="Castle.Core" Version="4.3.1" />
   </ItemGroup>
 
 </Project>

src/OmniSharp.Roslyn/WorkspaceServices/ExportWorkspaceServiceFactoryWithAssemblyQualifiedNameAttribute.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Composition;
+using System.Reflection;
+using Microsoft.CodeAnalysis.Host.Mef;
+
+namespace OmniSharp
+{
+    [MetadataAttribute]
+    [AttributeUsage(AttributeTargets.Class)]
+    public class ExportWorkspaceServiceFactoryWithAssemblyQualifiedNameAttribute : ExportAttribute
+    {
+        public string ServiceType { get; }
+        public string Layer { get; }
+
+        // Theres builtin public attribute for this, but since we target internal types
+        // this is needed to build service. MEF doesn't care is it internal or not.
+        public ExportWorkspaceServiceFactoryWithAssemblyQualifiedNameAttribute(string typeAssembly, string typeName, string layer = ServiceLayer.Host)
+            : base(typeof(IWorkspaceServiceFactory))
+        {
+            var type = Assembly.Load(typeAssembly).GetType(typeName)
+                ?? throw new InvalidOperationException($"Could not resolve '{typeName} from '{typeAssembly}'");
+
+            Console.WriteLine($"Resolved to type: {type.AssemblyQualifiedName}");
+            this.ServiceType = type.AssemblyQualifiedName;
+            this.Layer = layer ?? throw new ArgumentNullException(nameof(layer));
+        }
+    }
+}

src/OmniSharp.Roslyn/WorkspaceServices/ExtractInterfaceWorkspaceService.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using Castle.DynamicProxy;
+using Microsoft.CodeAnalysis;
+
+namespace OmniSharp
+{
+    public class ExtractInterfaceWorkspaceService : IInterceptor
+    {
+        public void Intercept(IInvocation invocation)
+        {
+            // IExtractInterfaceOptionsService and extract interface results are internal types -> workaround with proxy.
+            // This service simply passes all members through as selected and doesn't try show UI.
+            // When roslyn exposes this interface and members -> remove this workaround.
+
+            var resultTypeInternal = Assembly.Load("Microsoft.CodeAnalysis.Features").GetType("Microsoft.CodeAnalysis.ExtractInterface.ExtractInterfaceOptionsResult");
+            var enumType = resultTypeInternal.GetNestedTypes().Single(x => x.Name == "ExtractLocation");
+
+            var toSameFileEnumValue = Enum.Parse(enumType, "SameFile");
+
+            var interfaceName = invocation.Arguments[3] ?? throw new InvalidOperationException($"{nameof(ExtractInterfaceWorkspaceService)} default interface name was null.");
+
+            var resultObject = Activator.CreateInstance(resultTypeInternal, new object[] {
+                    false, // isCancelled
+                    ((List<ISymbol>)invocation.Arguments[2]).ToImmutableArray(), // InterfaceMembers selected -> select all.
+                    interfaceName,
+                    $"{interfaceName}.cs",
+                    toSameFileEnumValue
+                });
+
+            var fromResultMethod = typeof(Task).GetMethod("FromResult").MakeGenericMethod(resultTypeInternal).Invoke(null, new[] { resultObject });
+            invocation.ReturnValue = fromResultMethod;
+        }
+
+        private static Type MakeGenerictTaskTypeFromResult(Type resultTypeInternal)
+        {
+            var taskType = typeof(Task<>);
+            Type[] typeArgs = { resultTypeInternal };
+            var taskGenericType = taskType.MakeGenericType(typeArgs);
+            return taskGenericType;
+        }
+    }
+}

src/OmniSharp.Roslyn/WorkspaceServices/ExtractInterfaceWorkspaceServiceFactory.cs

@@ -0,0 +1,21 @@
+using System.Composition;
+using System.Reflection;
+using Castle.DynamicProxy;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+
+namespace OmniSharp
+{
+    [Shared]
+    [ExportWorkspaceServiceFactoryWithAssemblyQualifiedName("Microsoft.CodeAnalysis.Features", "Microsoft.CodeAnalysis.ExtractInterface.IExtractInterfaceOptionsService")]
+    public class ExtractInterfaceWorkspaceServiceFactory : IWorkspaceServiceFactory
+    {
+        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
+        {
+            // Generates proxy class to get around issue that IExtractInterfaceOptionsService is internal at this point.
+            ProxyGenerator generator = new ProxyGenerator();
+            var internalType = Assembly.Load("Microsoft.CodeAnalysis.Features").GetType("Microsoft.CodeAnalysis.ExtractInterface.IExtractInterfaceOptionsService");
+            return (IWorkspaceService)generator.CreateInterfaceProxyWithoutTarget(internalType, new[] { typeof(IWorkspaceService)}, new ExtractInterfaceWorkspaceService());
+        }
+    }
+}

src/OmniSharp.Roslyn/WorkspaceServices/PickMemberWorkspaceService.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Reflection;
+using Castle.DynamicProxy;
+
+namespace OmniSharp
+{
+    public class PickMemberWorkspaceService : IInterceptor
+    {
+        public void Intercept(IInvocation invocation)
+        {
+            // IPickMember and PickMemberResults are internal types -> workaround with proxy.
+            // This service simply passes all members through as selected and doesn't try show UI.
+            // When roslyn exposes this interface and members -> remove this workaround.
+            var resultTypeInternal = Assembly.Load("Microsoft.CodeAnalysis.Features").GetType("Microsoft.CodeAnalysis.PickMembers.PickMembersResult");
+            var resultInstance = Activator.CreateInstance(resultTypeInternal, new object[] { invocation.Arguments[1], invocation.Arguments[2] });
+            invocation.ReturnValue = resultInstance;
+        }
+    }
+}

src/OmniSharp.Roslyn/WorkspaceServices/PickMemberWorkspaceServiceFactory.cs

@@ -0,0 +1,21 @@
+using System.Composition;
+using System.Reflection;
+using Castle.DynamicProxy;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+
+namespace OmniSharp
+{
+    [Shared]
+    [ExportWorkspaceServiceFactoryWithAssemblyQualifiedName("Microsoft.CodeAnalysis.Features", "Microsoft.CodeAnalysis.PickMembers.IPickMembersService")]
+    public class PickMemberWorkspaceServiceFactory : IWorkspaceServiceFactory
+    {
+        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
+        {
+            // Generates proxy class to get around issue that IPickMembersService is internal at this point.
+            ProxyGenerator generator = new ProxyGenerator();
+            var internalType = Assembly.Load("Microsoft.CodeAnalysis.Features").GetType("Microsoft.CodeAnalysis.PickMembers.IPickMembersService");
+            return (IWorkspaceService)generator.CreateInterfaceProxyWithoutTarget(internalType, new[] { typeof(IWorkspaceService)}, new PickMemberWorkspaceService());
+        }
+    }
+}