Merge branch 'codeOrganization3' into addParameter

src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj

@@ -201,9 +201,9 @@
     <Compile Include="CodeActions\EncapsulateField\EncapsulateFieldTests.cs" />
     <Compile Include="CodeActions\ExtractMethod\ExtractMethodTests.cs" />
     <Compile Include="CodeActions\GenerateDefaultConstructors\GenerateDefaultConstructorsTests.cs" />
-    <Compile Include="CodeActions\GenerateFromMembers\AddConstructorParameters\AddConstructorParametersTests.cs" />
-    <Compile Include="CodeActions\GenerateFromMembers\GenerateConstructorFromMembers\GenerateConstructorFromMembersTests.cs" />
-    <Compile Include="CodeActions\GenerateFromMembers\GenerateEqualsAndGetHashCode\GenerateEqualsAndGetHashCodeTests.cs" />
+    <Compile Include="GenerateFromMembers\AddConstructorParametersFromMembers\AddConstructorParametersFromMembersTests.cs" />
+    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\GenerateConstructorFromMembersTests.cs" />
+    <Compile Include="GenerateFromMembers\GenerateEqualsAndGetHashCode\GenerateEqualsAndGetHashCodeTests.cs" />
     <Compile Include="CodeActions\InlineTemporary\InlineTemporaryTests.cs" />
     <Compile Include="CodeActions\IntroduceVariable\IntroduceVariableTests.cs" />
     <Compile Include="CodeActions\InvertIf\InvertIfTests.cs" />

src/EditorFeatures/CSharpTest/CodeActions/GenerateFromMembers/AddConstructorParameters/AddConstructorParametersTests.cs → src/EditorFeatures/CSharpTest/GenerateFromMembers/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersTests.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.AddConstructorParametersFromMembers;
 using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.CodeRefactorings.GenerateFromMembers.AddConstructorParameters;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings;
 using Roslyn.Test.Utilities;
 using Xunit;
 
-namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.GenerateFromMembers.AddConstructorParameters
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.GenerateFromMembers.AddConstructorParameters
 {
-    public class AddConstructorParametersTests : AbstractCSharpCodeActionTest
+    public class AddConstructorParametersFromMembersTests : AbstractCSharpCodeActionTest
     {
         protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace)
-        {
-            return new AddConstructorParametersCodeRefactoringProvider();
-        }
+            => new AddConstructorParametersFromMembersCodeRefactoringProvider();
 
-        [Fact, WorkItem(308077, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/308077"), Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, WorkItem(308077, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/308077"), Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestAdd1()
         {
             await TestAsync(
@@ -48,7 +47,7 @@ public Program(int i, string s)
 index: 0);
         }
 
-        [Fact, WorkItem(308077, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/308077"), Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, WorkItem(308077, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/308077"), Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestAddOptional1()
         {
             await TestAsync(
@@ -80,7 +79,7 @@ public Program(int i, string s = null)
 index: 1);
         }
 
-        [Fact, WorkItem(308077, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/308077"), Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, WorkItem(308077, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/308077"), Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestAddToConstructorWithMostMatchingParameters1()
         {
             await TestAsync(
@@ -124,7 +123,7 @@ public Program(int i, string s, bool b) : this(i)
 index: 0);
         }
 
-        [Fact, WorkItem(308077, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/308077"), Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, WorkItem(308077, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/308077"), Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestAddOptionalToConstructorWithMostMatchingParameters1()
         {
             await TestAsync(
@@ -168,7 +167,7 @@ public Program(int i, string s, bool b = default(bool)) : this(i)
 index: 1);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestSmartTagDisplayText1()
         {
             await TestSmartTagTextAsync(
@@ -188,7 +187,7 @@ public Program(bool b)
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestSmartTagDisplayText2()
         {
             await TestSmartTagTextAsync(
@@ -208,7 +207,7 @@ public Program(bool b)
 index: 1);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestTuple()
         {
             await TestAsync(
@@ -236,7 +235,7 @@ public Program((int, string) i, (string, int) s)
 index: 0, parseOptions: TestOptions.Regular, withScriptOption: true);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestTupleWithNames()
         {
             await TestAsync(
@@ -264,7 +263,7 @@ public Program((int a, string b) i, (string c, int d) s)
 index: 0, parseOptions: TestOptions.Regular, withScriptOption: true);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestTupleWithDifferentNames()
         {
             await TestMissingAsync(
@@ -281,7 +280,7 @@ public Program((int e, string f) i)
 parseOptions: TestOptions.Regular, withScriptOption: true);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestTupleOptional()
         {
             await TestAsync(
@@ -309,7 +308,7 @@ public Program((int, string) i, (string, int) s = default((string, int)))
 index: 1, parseOptions: TestOptions.Regular, withScriptOption: true);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestTupleOptionalWithNames()
         {
             await TestAsync(
@@ -337,7 +336,7 @@ public Program((int a, string b) i, (string c, int d) s = default((string c, int
 index: 1, parseOptions: TestOptions.Regular, withScriptOption: true);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestTupleOptionalWithDifferentNames()
         {
             await TestMissingAsync(
@@ -354,7 +353,7 @@ public Program((int e, string f) i)
 parseOptions: TestOptions.Regular, withScriptOption: true);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestTupleWithNullable()
         {
             await TestAsync(
@@ -382,7 +381,7 @@ public Program((int?, bool?) i, (byte?, long?) s)
 index: 0, parseOptions: TestOptions.Regular, withScriptOption: true);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
         public async Task TestTupleWithGenericss()
         {
             await TestAsync(

src/EditorFeatures/CSharpTest/CodeActions/GenerateFromMembers/GenerateConstructorFromMembers/GenerateConstructorFromMembersTests.cs → src/EditorFeatures/CSharpTest/GenerateFromMembers/GenerateConstructorFromMembers/GenerateConstructorFromMembersTests.cs

@@ -2,21 +2,20 @@
 
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.CodeRefactorings.GenerateFromMembers.GenerateConstructorFromMembers;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings;
+using Microsoft.CodeAnalysis.GenerateConstructorFromMembers;
 using Roslyn.Test.Utilities;
 using Xunit;
 
-namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.GenerateFromMembers.GenerateConstructorFromMembers
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.GenerateConstructorFromMembers
 {
     public class GenerateConstructorFromMembersTests : AbstractCSharpCodeActionTest
     {
         protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace)
-        {
-            return new GenerateConstructorFromMembersCodeRefactoringProvider();
-        }
+            => new GenerateConstructorFromMembersCodeRefactoringProvider();
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestSingleField()

src/EditorFeatures/CSharpTest/CodeActions/GenerateFromMembers/GenerateEqualsAndGetHashCode/GenerateEqualsAndGetHashCodeTests.cs → src/EditorFeatures/CSharpTest/GenerateFromMembers/GenerateEqualsAndGetHashCode/GenerateEqualsAndGetHashCodeTests.cs

@@ -2,21 +2,20 @@
 
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.CodeRefactorings.GenerateFromMembers.GenerateEqualsAndGetHashCode;
+using Microsoft.CodeAnalysis.GenerateEqualsAndGetHashCodeFromMembers;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings;
 using Roslyn.Test.Utilities;
 using Xunit;
 
-namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.GenerateFromMembers.GenerateEqualsAndGetHashCode
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.GenerateEqualsAndGetHashCodeFromMembers
 {
     public class GenerateEqualsAndGetHashCodeTests : AbstractCSharpCodeActionTest
     {
         protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace)
-        {
-            return new GenerateEqualsAndGetHashCodeCodeRefactoringProvider();
-        }
+            => new GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider();
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
         public async Task TestEqualsSingleField()

src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.SemanticChangedEventSource.cs

@@ -48,7 +48,10 @@ private void OnSubjectBufferChanged(object sender, TextContentChangedEventArgs e
             {
                 // Whenever this subject buffer has changed, we always consider that to be a 
                 // semantic change.
-                this.RaiseChanged();
+                if (e.Changes.Any())
+                {
+                    RaiseChanged();
+                }
             }
 
             private void OnOpenedDocumentSemanticChanged(object sender, Document document)

src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateConstructorCrossLanguageTests.vb

@@ -11,11 +11,11 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.GenerateConstructo
             If language = LanguageNames.CSharp Then
                 Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(
                     Nothing,
-                    New Microsoft.CodeAnalysis.CSharp.CodeFixes.GenerateConstructor.GenerateConstructorCodeFixProvider())
+                    New CodeAnalysis.CSharp.GenerateConstructor.GenerateConstructorCodeFixProvider())
             Else
                 Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(
                     Nothing,
-                    New Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateConstructor.GenerateConstructorCodeFixProvider())
+                    New CodeAnalysis.VisualBasic.GenerateConstructor.GenerateConstructorCodeFixProvider())
             End If
         End Function
 

src/EditorFeatures/TestUtilities/Traits.cs

@@ -27,7 +27,7 @@ public static class Features
             public const string ChangeSignature = nameof(ChangeSignature);
             public const string Classification = nameof(Classification);
             public const string ClassView = nameof(ClassView);
-            public const string CodeActionsAddConstructorParameters = "CodeActions.AddConstructorParameters";
+            public const string CodeActionsAddConstructorParametersFromMembers = "CodeActions.AddConstructorParametersFromMembers";
             public const string CodeActionsAddDocCommentNodes = "CodeActions.AddDocCommentParamNodes";
             public const string CodeActionsAddAsync = "CodeActions.AddAsync";
             public const string CodeActionsAddAwait = "CodeActions.AddAwait";
@@ -51,7 +51,7 @@ public static class Features
             public const string CodeActionsGenerateEndConstruct = "CodeActions.GenerateEndConstruct";
             public const string CodeActionsGenerateEnumMember = "CodeActions.GenerateEnumMember";
             public const string CodeActionsGenerateEvent = "CodeActions.GenerateEvent";
-            public const string CodeActionsGenerateEqualsAndGetHashCode = "CodeActions.GenerateEqualsAndGetHashCode";
+            public const string CodeActionsGenerateEqualsAndGetHashCode = "CodeActions.GenerateEqualsAndGetHashCodeFromMembers";
             public const string CodeActionsGenerateVariable = "CodeActions.GenerateVariable";
             public const string CodeActionsGenerateMethod = "CodeActions.GenerateMethod";
             public const string CodeActionsGenerateType = "CodeActions.GenerateType";

src/EditorFeatures/VisualBasicTest/CodeActions/GenerateFromMembers/AddConstructorParameters/AddConstructorParametersTests.vb → src/EditorFeatures/VisualBasicTest/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersTests.vb

 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+Imports Microsoft.CodeAnalysis.AddConstructorParametersFromMembers
 Imports Microsoft.CodeAnalysis.CodeRefactorings
-Imports Microsoft.CodeAnalysis.CodeRefactorings.GenerateFromMembers.AddConstructorParameters
+Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings
 
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings.GenerateConstructorFromMembers
-    Public Class AddConstructorParameterTests
+Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.AddConstructorParametersFromMembers
+    Public Class AddConstructorParameterFromMembersTests
         Inherits AbstractVisualBasicCodeActionTest
 
         Protected Overrides Function CreateCodeRefactoringProvider(workspace As Workspace) As CodeRefactoringProvider
-            Return New AddConstructorParametersCodeRefactoringProvider()
+            Return New AddConstructorParametersFromMembersCodeRefactoringProvider()
         End Function
 
         <WorkItem(530592, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530592")>
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)>
         Public Async Function TestAdd1() As Task
             Await TestAsync(
 "Class Program
@@ -33,7 +34,7 @@ End Class")
         End Function
 
         <WorkItem(530592, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530592")>
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)>
         Public Async Function TestAddOptional1() As Task
             Await TestAsync(
 "Class Program
@@ -55,7 +56,7 @@ index:=1)
         End Function
 
         <WorkItem(530592, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530592")>
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)>
         Public Async Function TestAddToConstructorWithMostMatchingParameters1() As Task
             Await TestAsync(
 "Class Program
@@ -86,7 +87,7 @@ End Class")
         End Function
 
         <WorkItem(530592, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530592")>
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParameters)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)>
         Public Async Function TestAddOptionalToConstructorWithMostMatchingParameters1() As Task
             Await TestAsync(
 "Class Program

src/EditorFeatures/VisualBasicTest/BasicEditorServicesTest.vbproj

@@ -187,9 +187,9 @@
     <Compile Include="CodeActions\EncapsulateField\EncapsulateFieldTests.vb" />
     <Compile Include="CodeActions\ExtractMethod\ExtractMethodTests.vb" />
     <Compile Include="CodeActions\GenerateDefaultConstructors\GenerateDefaultConstructorsTests.vb" />
-    <Compile Include="CodeActions\GenerateFromMembers\AddConstructorParameters\AddConstructorParametersTests.vb" />
-    <Compile Include="CodeActions\GenerateFromMembers\GenerateConstructorFromMembers\GenerateConstructorFromMembersTests.vb" />
-    <Compile Include="CodeActions\GenerateFromMembers\GenerateEqualsAndGetHashCode\GenerateEqualsAndGetHashCodeTests.vb" />
+    <Compile Include="AddConstructorParametersFromMembers\AddConstructorParametersFromMembersTests.vb" />
+    <Compile Include="GenerateConstructorFromMembers\GenerateConstructorFromMembersTests.vb" />
+    <Compile Include="GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersTests.vb" />
     <Compile Include="CodeActions\InlineTemporary\InlineTemporaryTests.vb" />
     <Compile Include="CodeActions\IntroduceVariable\IntroduceVariableTests.vb" />
     <Compile Include="CodeActions\InvertIf\InvertIfTests.vb" />
@@ -695,4 +695,4 @@
     </Content>
   </ItemGroup>
   <Import Project="..\..\..\build\Targets\Imports.targets" />
-</Project>
+</Project>
\ No newline at end of file

src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateConstructor/GenerateConstructorTests.vb

@@ -2,8 +2,8 @@
 
 Imports Microsoft.CodeAnalysis.CodeFixes
 Imports Microsoft.CodeAnalysis.Diagnostics
-Imports Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateConstructor
 Imports Microsoft.CodeAnalysis.VisualBasic.Diagnostics
+Imports Microsoft.CodeAnalysis.VisualBasic.GenerateConstructor
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics.GenerateConstructor
     Public Class GenerateConstructorTests

src/EditorFeatures/VisualBasicTest/CodeActions/GenerateFromMembers/GenerateConstructorFromMembers/GenerateConstructorFromMembersTests.vb → src/EditorFeatures/VisualBasicTest/GenerateConstructorFromMembers/GenerateConstructorFromMembersTests.vb

 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports Microsoft.CodeAnalysis.CodeRefactorings
-Imports Microsoft.CodeAnalysis.CodeRefactorings.GenerateFromMembers.GenerateConstructorFromMembers
+Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings
+Imports Microsoft.CodeAnalysis.GenerateConstructorFromMembers
 
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings.GenerateConstructorFromMembers
+Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.GenerateConstructorFromMembers
     Public Class GenerateConstructorFromMembersTests
         Inherits AbstractVisualBasicCodeActionTest
 

src/EditorFeatures/VisualBasicTest/CodeActions/GenerateFromMembers/GenerateEqualsAndGetHashCode/GenerateEqualsAndGetHashCodeTests.vb → src/EditorFeatures/VisualBasicTest/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeFromMembersTests.vb

 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports Microsoft.CodeAnalysis.CodeRefactorings
-Imports Microsoft.CodeAnalysis.CodeRefactorings.GenerateFromMembers.GenerateEqualsAndGetHashCode
+Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings
+Imports Microsoft.CodeAnalysis.GenerateEqualsAndGetHashCodeFromMembers
 
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings.GenerateConstructorFromMembers
-    Public Class GenerateEqualsAndGetHashCodeTests
+Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.GenerateConstructorFromMembers
+    Public Class GenerateEqualsAndGetHashCodeFromMembersTests
         Inherits AbstractVisualBasicCodeActionTest
 
         Protected Overrides Function CreateCodeRefactoringProvider(workspace As Workspace) As CodeRefactoringProvider
-            Return New GenerateEqualsAndGetHashCodeCodeRefactoringProvider()
+            Return New GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider()
         End Function
 
         <WorkItem(541991, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541991")>

src/Features/CSharp/Portable/CSharpFeatures.csproj

@@ -71,6 +71,7 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>CSharpFeaturesResources.resx</DependentUpon>
     </Compile>
+    <Compile Include="GenerateFromMembers\GenerateFromMembersHelpers.cs" />
     <Compile Include="ImplementAbstractClass\CSharpImplementAbstractClassCodeFixProvider.cs" />
     <Compile Include="ImplementInterface\CSharpImplementInterfaceCodeFixProvider.cs" />
     <Compile Include="Structure\Providers\ArrowExpressionClauseStructureProvider.cs" />
@@ -335,10 +336,6 @@
     <Compile Include="ExtractMethod\CSharpSyntaxTriviaService.cs" />
     <Compile Include="ExtractMethod\CSharpSyntaxTriviaServiceFactory.cs" />
     <Compile Include="ExtractMethod\Extensions.cs" />
-    <Compile Include="GenerateFromMembers\AddConstructorParameters\CSharpAddConstructorParametersService.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\CSharpGenerateConstructorFromMembersService.cs" />
-    <Compile Include="GenerateFromMembers\GenerateEqualsAndGetHashCode\CSharpGenerateEqualsAndGetHashCodeService.cs" />
-    <Compile Include="GenerateFromMembers\GenerateFromMembersHelpers.cs" />
     <Compile Include="GenerateConstructor\CSharpGenerateConstructorService.cs" />
     <Compile Include="GenerateMember\GenerateDefaultConstructors\CSharpGenerateDefaultConstructorsService.cs" />
     <Compile Include="GenerateMember\GenerateEnumMember\CSharpGenerateEnumMemberService.cs" />

src/Features/CSharp/Portable/GenerateFromMembers/AddConstructorParameters/CSharpAddConstructorParametersService.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Generic;
-using System.Composition;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.GenerateFromMembers.AddConstructorParameters;
-using Microsoft.CodeAnalysis.Host.Mef;
-using Microsoft.CodeAnalysis.Text;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.CSharp.GenerateFromMembers.AddConstructorParameters
-{
-    [ExportLanguageService(typeof(IAddConstructorParametersService), LanguageNames.CSharp), Shared]
-    internal class CSharpAddConstructorParametersService :
-        AbstractAddConstructorParametersService<CSharpAddConstructorParametersService, MemberDeclarationSyntax>
-    {
-        protected override async Task<IList<MemberDeclarationSyntax>> GetSelectedMembersAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken)
-        {
-            if (cancellationToken.IsCancellationRequested)
-            {
-                return SpecializedCollections.EmptyList<MemberDeclarationSyntax>();
-            }
-            else
-            {
-                return await GenerateFromMembersHelpers.GetSelectedMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
-            }
-        }
-
-        protected override IEnumerable<ISymbol> GetDeclaredSymbols(SemanticModel semanticModel, MemberDeclarationSyntax memberDeclaration, CancellationToken cancellationToken)
-        {
-            return GenerateFromMembersHelpers.GetDeclaredSymbols(semanticModel, memberDeclaration, cancellationToken);
-        }
-    }
-}

src/Features/CSharp/Portable/GenerateFromMembers/GenerateConstructorFromMembers/CSharpGenerateConstructorFromMembersService.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Generic;
-using System.Composition;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers;
-using Microsoft.CodeAnalysis.Host.Mef;
-using Microsoft.CodeAnalysis.Text;
-
-namespace Microsoft.CodeAnalysis.CSharp.GenerateFromMembers.GenerateConstructorFromMembers
-{
-    [ExportLanguageService(typeof(IGenerateConstructorFromMembersService), LanguageNames.CSharp), Shared]
-    internal class CSharpGenerateConstructorFromMembersService :
-        AbstractGenerateConstructorFromMembersService<CSharpGenerateConstructorFromMembersService, MemberDeclarationSyntax>
-    {
-        protected override Task<IList<MemberDeclarationSyntax>> GetSelectedMembersAsync(
-            Document document, TextSpan textSpan, CancellationToken cancellationToken)
-        {
-            return GenerateFromMembersHelpers.GetSelectedMembersAsync(document, textSpan, cancellationToken);
-        }
-
-        protected override IEnumerable<ISymbol> GetDeclaredSymbols(
-            SemanticModel semanticModel, MemberDeclarationSyntax memberDeclaration, CancellationToken cancellationToken)
-        {
-            return GenerateFromMembersHelpers.GetDeclaredSymbols(semanticModel, memberDeclaration, cancellationToken);
-        }
-    }
-}

src/Features/CSharp/Portable/GenerateFromMembers/GenerateEqualsAndGetHashCode/CSharpGenerateEqualsAndGetHashCodeService.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Generic;
-using System.Composition;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.GenerateFromMembers.GenerateEqualsAndGetHashCode;
-using Microsoft.CodeAnalysis.Host.Mef;
-using Microsoft.CodeAnalysis.Text;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.CSharp.GenerateFromMembers.GenerateEqualsAndGetHashCode
-{
-    [ExportLanguageService(typeof(IGenerateEqualsAndGetHashCodeService), LanguageNames.CSharp), Shared]
-    internal class CSharpGenerateEqualsAndGetHashCodeService :
-        AbstractGenerateEqualsAndGetHashCodeService<CSharpGenerateEqualsAndGetHashCodeService, MemberDeclarationSyntax>
-    {
-        protected override async Task<IList<MemberDeclarationSyntax>> GetSelectedMembersAsync(
-            Document document, TextSpan textSpan, CancellationToken cancellationToken)
-        {
-            if (cancellationToken.IsCancellationRequested)
-            {
-                return SpecializedCollections.EmptyList<MemberDeclarationSyntax>();
-            }
-            else
-            {
-                return await GenerateFromMembersHelpers.GetSelectedMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
-            }
-        }
-
-        protected override IEnumerable<ISymbol> GetDeclaredSymbols(
-            SemanticModel semanticModel, MemberDeclarationSyntax memberDeclaration, CancellationToken cancellationToken)
-        {
-            return GenerateFromMembersHelpers.GetDeclaredSymbols(semanticModel, memberDeclaration, cancellationToken);
-        }
-    }
-}

src/Features/CSharp/Portable/GenerateFromMembers/GenerateFromMembersHelpers.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Composition;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.GenerateFromMembers;
+using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.GenerateFromMembers
 {
-    internal static class GenerateFromMembersHelpers
+    [ExportLanguageService(typeof(IGenerateFromMembersHelperService), LanguageNames.CSharp), Shared]
+    internal class CSharpGenerateFromMembersHelpersService : IGenerateFromMembersHelperService
     {
-        internal static async Task<IList<MemberDeclarationSyntax>> GetSelectedMembersAsync(
+        public async Task<ImmutableArray<SyntaxNode>> GetSelectedMembersAsync(
             Document document, TextSpan textSpan, CancellationToken cancellationToken)
         {
             var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
-            return tree.GetMembersInSpan(textSpan, cancellationToken);
+            return ImmutableArray<SyntaxNode>.CastUp(tree.GetMembersInSpan(textSpan, cancellationToken));
         }
 
-        internal static IEnumerable<ISymbol> GetDeclaredSymbols(SemanticModel semanticModel, MemberDeclarationSyntax memberDeclaration, CancellationToken cancellationToken)
+        public IEnumerable<ISymbol> GetDeclaredSymbols(SemanticModel semanticModel, SyntaxNode memberDeclaration, CancellationToken cancellationToken)
         {
-            if (memberDeclaration is FieldDeclarationSyntax)
+            if (memberDeclaration is FieldDeclarationSyntax field)
             {
-                return ((FieldDeclarationSyntax)memberDeclaration).Declaration.Variables.Select(
+                return field.Declaration.Variables.Select(
                     v => semanticModel.GetDeclaredSymbol(v, cancellationToken));
             }
 
@@ -32,4 +37,4 @@ internal static IEnumerable<ISymbol> GetDeclaredSymbols(SemanticModel semanticMo
                 semanticModel.GetDeclaredSymbol(memberDeclaration, cancellationToken));
         }
     }
-}
+}
\ No newline at end of file

src/Features/Core/Portable/GenerateFromMembers/AddConstructorParameters/AbstractAddConstructorParametersService.CodeAction.cs → src/Features/Core/Portable/AddConstructorParametersFromMembers/AddConstructorParametersCodeAction.cs

@@ -12,19 +12,19 @@
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.AddConstructorParameters
+namespace Microsoft.CodeAnalysis.AddConstructorParametersFromMembers
 {
-    internal abstract partial class AbstractAddConstructorParametersService<TService, TMemberDeclarationSyntax>
+    internal partial class AddConstructorParametersFromMembersCodeRefactoringProvider
     {
         private class AddConstructorParametersCodeAction : CodeAction
         {
-            private readonly TService _service;
+            private readonly AddConstructorParametersFromMembersCodeRefactoringProvider _service;
             private readonly Document _document;
             private readonly State _state;
             private readonly IList<IParameterSymbol> _parameters;
 
             public AddConstructorParametersCodeAction(
-                TService service,
+                AddConstructorParametersFromMembersCodeRefactoringProvider service,
                 Document document,
                 State state,
                 IList<IParameterSymbol> parameters)

src/Features/Core/Portable/GenerateFromMembers/AddConstructorParameters/AbstractAddConstructorParametersService.cs → src/Features/Core/Portable/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersCodeRefactoringProvider.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Composition;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeGeneration;
+using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.GenerateFromMembers;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.AddConstructorParameters
+namespace Microsoft.CodeAnalysis.AddConstructorParametersFromMembers
 {
-    internal abstract partial class AbstractAddConstructorParametersService<TService, TMemberDeclarationSyntax> :
-            AbstractGenerateFromMembersService<TMemberDeclarationSyntax>, IAddConstructorParametersService
-        where TService : AbstractAddConstructorParametersService<TService, TMemberDeclarationSyntax>
-        where TMemberDeclarationSyntax : SyntaxNode
+    [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic,
+        Name = PredefinedCodeRefactoringProviderNames.AddConstructorParametersFromMembers), Shared]
+    [ExtensionOrder(After = PredefinedCodeRefactoringProviderNames.GenerateConstructorFromMembers)]
+    internal partial class AddConstructorParametersFromMembersCodeRefactoringProvider : AbstractGenerateFromMembersCodeRefactoringProvider
     {
-        protected AbstractAddConstructorParametersService()
+        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
         {
+            var document = context.Document;
+            var textSpan = context.Span;
+            var cancellationToken = context.CancellationToken;
+
+            if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
+            {
+                return;
+            }
+
+            var actions = await this.AddConstructorParametersFromMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
+            if (!actions.IsDefault)
+            {
+                context.RegisterRefactorings(actions);
+            }
         }
 
-        public async Task<ImmutableArray<CodeAction>> AddConstructorParametersAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken)
+        public async Task<ImmutableArray<CodeAction>> AddConstructorParametersFromMembersAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken)
         {
-            using (Logger.LogBlock(FunctionId.Refactoring_GenerateFromMembers_AddConstructorParameters, cancellationToken))
+            using (Logger.LogBlock(FunctionId.Refactoring_GenerateFromMembers_AddConstructorParametersFromMembers, cancellationToken))
             {
                 var info = await this.GetSelectedMemberInfoAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
                 if (info != null)
                 {
-                    var state = State.Generate((TService)this, document, textSpan, info.SelectedMembers, cancellationToken);
+                    var state = State.Generate(this, document, textSpan, info.SelectedMembers, cancellationToken);
                     if (state != null)
                     {
                         return CreateCodeActions(document, state).AsImmutableOrNull();
@@ -44,7 +61,7 @@ private IEnumerable<CodeAction> CreateCodeActions(Document document, State state
             var lastParameter = state.DelegatedConstructor.Parameters.Last();
             if (!lastParameter.IsOptional)
             {
-                yield return new AddConstructorParametersCodeAction((TService)this, document, state, state.Parameters);
+                yield return new AddConstructorParametersCodeAction(this, document, state, state.Parameters);
             }
 
             var parameters = state.Parameters.Select(p => CodeGenerationSymbolFactory.CreateParameterSymbol(
@@ -56,7 +73,7 @@ private IEnumerable<CodeAction> CreateCodeActions(Document document, State state
                 isOptional: true,
                 hasDefaultValue: true)).ToList();
 
-            yield return new AddConstructorParametersCodeAction((TService)this, document, state, parameters);
+            yield return new AddConstructorParametersCodeAction(this, document, state, parameters);
         }
     }
-}
+}
\ No newline at end of file

src/Features/Core/Portable/GenerateFromMembers/AddConstructorParameters/AbstractAddConstructorParametersService.State.cs → src/Features/Core/Portable/AddConstructorParametersFromMembers/State.cs

@@ -6,9 +6,9 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.AddConstructorParameters
+namespace Microsoft.CodeAnalysis.AddConstructorParametersFromMembers
 {
-    internal abstract partial class AbstractAddConstructorParametersService<TService, TMemberDeclarationSyntax>
+    internal partial class AddConstructorParametersFromMembersCodeRefactoringProvider
     {
         private class State
         {
@@ -19,7 +19,7 @@ private class State
             public List<IParameterSymbol> Parameters { get; private set; }
 
             public static State Generate(
-                TService service,
+                AddConstructorParametersFromMembersCodeRefactoringProvider service,
                 Document document,
                 TextSpan textSpan,
                 IList<ISymbol> selectedMembers,
@@ -35,7 +35,7 @@ private class State
             }
 
             private bool TryInitialize(
-                TService service,
+                AddConstructorParametersFromMembersCodeRefactoringProvider service,
                 Document document,
                 TextSpan textSpan,
                 IList<ISymbol> selectedMembers,

src/Features/Core/Portable/CodeRefactorings/GenerateFromMembers/AddConstructorParameters/AddConstructorParametersCodeRefactoringProvider.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Composition;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.GenerateFromMembers.AddConstructorParameters;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-
-namespace Microsoft.CodeAnalysis.CodeRefactorings.GenerateFromMembers.AddConstructorParameters
-{
-    [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic,
-        Name = PredefinedCodeRefactoringProviderNames.AddConstructorParametersFromMembers), Shared]
-    [ExtensionOrder(After = PredefinedCodeRefactoringProviderNames.GenerateConstructorFromMembers)]
-    internal class AddConstructorParametersCodeRefactoringProvider : CodeRefactoringProvider
-    {
-        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
-        {
-            var document = context.Document;
-            var textSpan = context.Span;
-            var cancellationToken = context.CancellationToken;
-
-            if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
-            {
-                return;
-            }
-
-            var service = document.GetLanguageService<IAddConstructorParametersService>();
-            var actions = await service.AddConstructorParametersAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
-            if (!actions.IsDefault)
-            {
-                context.RegisterRefactorings(actions);
-            }
-        }
-    }
-}
\ No newline at end of file

src/Features/Core/Portable/CodeRefactorings/GenerateFromMembers/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Composition;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-
-namespace Microsoft.CodeAnalysis.CodeRefactorings.GenerateFromMembers.GenerateConstructorFromMembers
-{
-    [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic,
-        Name = PredefinedCodeRefactoringProviderNames.GenerateConstructorFromMembers), Shared]
-    [ExtensionOrder(Before = PredefinedCodeRefactoringProviderNames.AddConstructorParametersFromMembers)]
-    internal class GenerateConstructorFromMembersCodeRefactoringProvider : CodeRefactoringProvider
-    {
-        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
-        {
-            var document = context.Document;
-            var textSpan = context.Span;
-            var cancellationToken = context.CancellationToken;
-
-            if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
-            {
-                return;
-            }
-
-            var service = document.GetLanguageService<IGenerateConstructorFromMembersService>();
-            var actions = await service.GenerateConstructorFromMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
-            if (!actions.IsDefault)
-            {
-                context.RegisterRefactorings(actions);
-            }
-        }
-    }
-}
\ No newline at end of file

src/Features/Core/Portable/CodeRefactorings/GenerateFromMembers/GenerateEqualsAndGetHashCode/GenerateEqualsAndGetHashCodeCodeRefactoringProvider.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.GenerateFromMembers.GenerateEqualsAndGetHashCode;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-
-namespace Microsoft.CodeAnalysis.CodeRefactorings.GenerateFromMembers.GenerateEqualsAndGetHashCode
-{
-    // [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic, PredefinedCodeRefactoringProviderNames.GenerateEqualsAndGetHashCode)]
-    [ExtensionOrder(After = PredefinedCodeRefactoringProviderNames.GenerateConstructorFromMembers, Before = PredefinedCodeRefactoringProviderNames.AddConstructorParametersFromMembers)]
-    internal class GenerateEqualsAndGetHashCodeCodeRefactoringProvider : CodeRefactoringProvider
-    {
-        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
-        {
-            var document = context.Document;
-            var textSpan = context.Span;
-            var cancellationToken = context.CancellationToken;
-
-            if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
-            {
-                return;
-            }
-
-            var service = document.GetLanguageService<IGenerateEqualsAndGetHashCodeService>();
-            var actions = await service.GenerateEqualsAndGetHashCodeAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
-            if (!actions.IsDefault)
-            {
-                context.RegisterRefactorings(actions);
-            }
-        }
-    }
-}
\ No newline at end of file

src/Features/Core/Portable/CodeRefactorings/PredefinedCodeRefactoringProviderNames.cs

@@ -11,7 +11,7 @@ internal static class PredefinedCodeRefactoringProviderNames
         public const string ExtractMethod = "Extract Method Code Action Provider";
         public const string GenerateConstructorFromMembers = "Generate Constructor From Members Code Action Provider";
         public const string GenerateDefaultConstructors = "Generate Default Constructors Code Action Provider";
-        public const string GenerateEqualsAndGetHashCode = "Generate Equals and GetHashCode Code Action Provider";
+        public const string GenerateEqualsAndGetHashCodeFromMembers = "Generate Equals and GetHashCode Code Action Provider";
         public const string InlineTemporary = "Inline Temporary Code Action Provider";
         public const string IntroduceVariable = "Introduce Variable Code Action Provider";
         public const string InvertIf = "Invert If Code Action Provider";

src/Features/Core/Portable/Features.csproj

@@ -125,6 +125,7 @@
     </Compile>
     <Compile Include="CodeFixes\FixAllOccurrences\FixSomeCodeAction.cs" />
     <Compile Include="AddPackage\InstallPackageDirectlyCodeAction.cs" />
+    <Compile Include="AddConstructorParametersFromMembers\State.cs" />
     <Compile Include="ImplementType\ImplementTypeOptions.cs" />
     <Compile Include="ImplementType\ImplementTypeOptionsProvider.cs" />
     <Compile Include="RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsCodeFixProvider.cs" />
@@ -247,9 +248,9 @@
     <Compile Include="ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs" />
     <Compile Include="CodeRefactorings\ExtractMethod\AbstractExtractMethodCodeRefactoringProvider.cs" />
     <Compile Include="CodeRefactorings\GenerateDefaultConstructors\GenerateDefaultConstructorsCodeRefactoringProvider.cs" />
-    <Compile Include="CodeRefactorings\GenerateFromMembers\AddConstructorParameters\AddConstructorParametersCodeRefactoringProvider.cs" />
-    <Compile Include="CodeRefactorings\GenerateFromMembers\GenerateConstructorFromMembers\GenerateConstructorFromMembersCodeRefactoringProvider.cs" />
-    <Compile Include="CodeRefactorings\GenerateFromMembers\GenerateEqualsAndGetHashCode\GenerateEqualsAndGetHashCodeCodeRefactoringProvider.cs" />
+    <Compile Include="AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs" />
+    <Compile Include="GenerateConstructorFromMembers\GenerateConstructorFromMembersCodeRefactoringProvider.cs" />
+    <Compile Include="GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs" />
     <Compile Include="CodeRefactorings\ICodeRefactoringHelpersService.cs" />
     <Compile Include="CodeRefactorings\ICodeRefactoringService.cs" />
     <Compile Include="CodeRefactorings\IntroduceVariable\IntroduceVariableCodeRefactoringProvider.cs" />
@@ -508,18 +509,11 @@
     <Compile Include="ExtractMethod\UniqueNameGenerator.cs" />
     <Compile Include="ExtractMethod\VariableStyle.cs" />
     <Compile Include="GenerateFromMembers\AbstractGenerateFromMembersService.cs" />
-    <Compile Include="GenerateFromMembers\AddConstructorParameters\AbstractAddConstructorParametersService.CodeAction.cs" />
-    <Compile Include="GenerateFromMembers\AddConstructorParameters\AbstractAddConstructorParametersService.cs" />
-    <Compile Include="GenerateFromMembers\AddConstructorParameters\AbstractAddConstructorParametersService.State.cs" />
-    <Compile Include="GenerateFromMembers\AddConstructorParameters\IAddConstructorParametersService.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersService.ConstructorDelegatingCodeAction.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersService.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersService.FieldDelegatingCodeAction.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersService.State.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\IGenerateConstructorFromMembersService.cs" />
-    <Compile Include="GenerateFromMembers\GenerateEqualsAndGetHashCode\AbstractGenerateEqualsAndGetHashCodeService.cs" />
-    <Compile Include="GenerateFromMembers\GenerateEqualsAndGetHashCode\GenerateEqualsAndGetHashCodeCodeRefactoringProvider.CodeAction.cs" />
-    <Compile Include="GenerateFromMembers\GenerateEqualsAndGetHashCode\IGenerateEqualsAndGetHashCodeService.cs" />
+    <Compile Include="AddConstructorParametersFromMembers\AddConstructorParametersCodeAction.cs" />
+    <Compile Include="GenerateConstructorFromMembers\ConstructorDelegatingCodeAction.cs" />
+    <Compile Include="GenerateConstructorFromMembers\FieldDelegatingCodeAction.cs" />
+    <Compile Include="GenerateConstructorFromMembers\State.cs" />
+    <Compile Include="GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndHashCodeAction.cs" />
     <Compile Include="GenerateMember\AbstractGenerateMemberService.cs" />
     <Compile Include="GenerateMember\GenerateConstructor\AbstractGenerateConstructorService.CodeAction.cs" />
     <Compile Include="GenerateMember\GenerateConstructor\AbstractGenerateConstructorService.cs" />

src/Features/Core/Portable/GenerateFromMembers/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersService.ConstructorDelegatingCodeAction.cs → src/Features/Core/Portable/GenerateConstructorFromMembers/ConstructorDelegatingCodeAction.cs

@@ -10,18 +10,18 @@
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
+namespace Microsoft.CodeAnalysis.GenerateConstructorFromMembers
 {
-    internal abstract partial class AbstractGenerateConstructorFromMembersService<TService, TMemberDeclarationSyntax>
+    internal partial class GenerateConstructorFromMembersCodeRefactoringProvider
     {
         private class ConstructorDelegatingCodeAction : CodeAction
         {
-            private readonly TService _service;
+            private readonly GenerateConstructorFromMembersCodeRefactoringProvider _service;
             private readonly Document _document;
             private readonly State _state;
 
             public ConstructorDelegatingCodeAction(
-                TService service,
+                GenerateConstructorFromMembersCodeRefactoringProvider service,
                 Document document,
                 State state)
             {
@@ -92,4 +92,4 @@ public override string Title
             }
         }
     }
-}
+}
\ No newline at end of file

src/Features/Core/Portable/GenerateFromMembers/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersService.FieldDelegatingCodeAction.cs → src/Features/Core/Portable/GenerateConstructorFromMembers/FieldDelegatingCodeAction.cs

@@ -10,18 +10,18 @@
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
+namespace Microsoft.CodeAnalysis.GenerateConstructorFromMembers
 {
-    internal abstract partial class AbstractGenerateConstructorFromMembersService<TService, TMemberDeclarationSyntax>
+    internal partial class GenerateConstructorFromMembersCodeRefactoringProvider
     {
         private class FieldDelegatingCodeAction : CodeAction
         {
-            private readonly TService _service;
+            private readonly GenerateConstructorFromMembersCodeRefactoringProvider _service;
             private readonly Document _document;
             private readonly State _state;
 
             public FieldDelegatingCodeAction(
-                TService service,
+                GenerateConstructorFromMembersCodeRefactoringProvider service,
                 Document document,
                 State state)
             {
@@ -88,4 +88,4 @@ public override string Title
             }
         }
     }
-}
+}
\ No newline at end of file

src/Features/Core/Portable/GenerateFromMembers/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersService.cs → src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Composition;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.GenerateFromMembers;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
+namespace Microsoft.CodeAnalysis.GenerateConstructorFromMembers
 {
-    internal abstract partial class AbstractGenerateConstructorFromMembersService<TService, TMemberDeclarationSyntax> :
-            AbstractGenerateFromMembersService<TMemberDeclarationSyntax>, IGenerateConstructorFromMembersService
-        where TService : AbstractGenerateConstructorFromMembersService<TService, TMemberDeclarationSyntax>
-        where TMemberDeclarationSyntax : SyntaxNode
+    [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic,
+        Name = PredefinedCodeRefactoringProviderNames.GenerateConstructorFromMembers), Shared]
+    [ExtensionOrder(Before = PredefinedCodeRefactoringProviderNames.AddConstructorParametersFromMembers)]
+    internal partial class GenerateConstructorFromMembersCodeRefactoringProvider : AbstractGenerateFromMembersCodeRefactoringProvider
     {
-        protected AbstractGenerateConstructorFromMembersService()
+        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
         {
+            var document = context.Document;
+            var textSpan = context.Span;
+            var cancellationToken = context.CancellationToken;
+
+            if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
+            {
+                return;
+            }
+
+            var actions = await this.GenerateConstructorFromMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
+            if (!actions.IsDefault)
+            {
+                context.RegisterRefactorings(actions);
+            }
         }
 
         public async Task<ImmutableArray<CodeAction>> GenerateConstructorFromMembersAsync(
             Document document, TextSpan textSpan, CancellationToken cancellationToken)
         {
-            using (Logger.LogBlock(FunctionId.Refactoring_GenerateFromMembers_GenerateConstructor, cancellationToken))
+            using (Logger.LogBlock(FunctionId.Refactoring_GenerateFromMembers_GenerateConstructorFromMembers, cancellationToken))
             {
                 var info = await GetSelectedMemberInfoAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
                 if (info != null)
                 {
-                    var state = State.Generate((TService)this, document, textSpan, info.ContainingType, info.SelectedMembers, cancellationToken);
+                    var state = State.Generate(this, document, textSpan, info.ContainingType, info.SelectedMembers, cancellationToken);
                     if (state != null)
                     {
                         return GetCodeActions(document, state).AsImmutableOrNull();
@@ -40,11 +57,11 @@ protected AbstractGenerateConstructorFromMembersService()
 
         private IEnumerable<CodeAction> GetCodeActions(Document document, State state)
         {
-            yield return new FieldDelegatingCodeAction((TService)this, document, state);
+            yield return new FieldDelegatingCodeAction(this, document, state);
             if (state.DelegatedConstructor != null)
             {
-                yield return new ConstructorDelegatingCodeAction((TService)this, document, state);
+                yield return new ConstructorDelegatingCodeAction(this, document, state);
             }
         }
     }
-}
+}
\ No newline at end of file

src/Features/Core/Portable/GenerateFromMembers/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersService.State.cs → src/Features/Core/Portable/GenerateConstructorFromMembers/State.cs

@@ -6,9 +6,9 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
+namespace Microsoft.CodeAnalysis.GenerateConstructorFromMembers
 {
-    internal abstract partial class AbstractGenerateConstructorFromMembersService<TService, TMemberDeclarationSyntax>
+    internal partial class GenerateConstructorFromMembersCodeRefactoringProvider
     {
         private class State
         {
@@ -19,7 +19,7 @@ private class State
             public List<IParameterSymbol> Parameters { get; private set; }
 
             public static State Generate(
-                TService service,
+                GenerateConstructorFromMembersCodeRefactoringProvider service,
                 Document document,
                 TextSpan textSpan,
                 INamedTypeSymbol containingType,
@@ -36,7 +36,7 @@ private class State
             }
 
             private bool TryInitialize(
-                TService service,
+                GenerateConstructorFromMembersCodeRefactoringProvider service,
                 Document document,
                 TextSpan textSpan,
                 INamedTypeSymbol containingType,

src/Features/Core/Portable/GenerateFromMembers/GenerateEqualsAndGetHashCode/AbstractGenerateEqualsAndGetHashCodeService.cs → src/Features/Core/Portable/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -7,25 +7,41 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.GenerateFromMembers;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateEqualsAndGetHashCode
+namespace Microsoft.CodeAnalysis.GenerateEqualsAndGetHashCodeFromMembers
 {
-    internal abstract partial class AbstractGenerateEqualsAndGetHashCodeService<TService, TMemberDeclarationSyntax> :
-        AbstractGenerateFromMembersService<TMemberDeclarationSyntax>, IGenerateEqualsAndGetHashCodeService
-        where TService : AbstractGenerateEqualsAndGetHashCodeService<TService, TMemberDeclarationSyntax>
-        where TMemberDeclarationSyntax : SyntaxNode
+    // [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic, PredefinedCodeRefactoringProviderNames.GenerateEqualsAndGetHashCodeFromMembers)]
+    [ExtensionOrder(After = PredefinedCodeRefactoringProviderNames.GenerateConstructorFromMembers,
+                    Before = PredefinedCodeRefactoringProviderNames.AddConstructorParametersFromMembers)]
+    internal partial class GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider : AbstractGenerateFromMembersCodeRefactoringProvider
     {
+        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
+        {
+            var document = context.Document;
+            var textSpan = context.Span;
+            var cancellationToken = context.CancellationToken;
+
+            if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
+            {
+                return;
+            }
+
+            var actions = await this.GenerateEqualsAndGetHashCodeFromMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
+            if (!actions.IsDefault)
+            {
+                context.RegisterRefactorings(actions);
+            }
+        }
+
         private const string EqualsName = "Equals";
         private const string GetHashCodeName = "GetHashCode";
         private const string ObjName = nameof(ObjName);
 
-        protected AbstractGenerateEqualsAndGetHashCodeService()
-        {
-        }
-
-        public async Task<ImmutableArray<CodeAction>> GenerateEqualsAndGetHashCodeAsync(
+        public async Task<ImmutableArray<CodeAction>> GenerateEqualsAndGetHashCodeFromMembersAsync(
             Document document,
             TextSpan textSpan,
             CancellationToken cancellationToken)
@@ -70,18 +86,18 @@ protected AbstractGenerateEqualsAndGetHashCodeService()
         {
             if (!hasEquals)
             {
-                yield return new GenerateEqualsAndHashCodeAction((TService)this, document, textSpan, containingType, selectedMembers, generateEquals: true);
+                yield return new GenerateEqualsAndHashCodeAction(this, document, textSpan, containingType, selectedMembers, generateEquals: true);
             }
 
             if (!hasGetHashCode)
             {
-                yield return new GenerateEqualsAndHashCodeAction((TService)this, document, textSpan, containingType, selectedMembers, generateGetHashCode: true);
+                yield return new GenerateEqualsAndHashCodeAction(this, document, textSpan, containingType, selectedMembers, generateGetHashCode: true);
             }
 
             if (!hasEquals && !hasGetHashCode)
             {
-                yield return new GenerateEqualsAndHashCodeAction((TService)this, document, textSpan, containingType, selectedMembers, generateEquals: true, generateGetHashCode: true);
+                yield return new GenerateEqualsAndHashCodeAction(this, document, textSpan, containingType, selectedMembers, generateEquals: true, generateGetHashCode: true);
             }
         }
     }
-}
+}
\ No newline at end of file

src/Features/Core/Portable/GenerateFromMembers/GenerateEqualsAndGetHashCode/GenerateEqualsAndGetHashCodeCodeRefactoringProvider.CodeAction.cs → src/Features/Core/Portable/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndHashCodeAction.cs

@@ -9,22 +9,22 @@
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateEqualsAndGetHashCode
+namespace Microsoft.CodeAnalysis.GenerateEqualsAndGetHashCodeFromMembers
 {
-    internal abstract partial class AbstractGenerateEqualsAndGetHashCodeService<TService, TMemberDeclarationSyntax>
+    internal partial class GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider
     {
         private class GenerateEqualsAndHashCodeAction : CodeAction
         {
             private readonly bool _generateEquals;
             private readonly bool _generateGetHashCode;
-            private readonly TService _service;
+            private readonly GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider _service;
             private readonly Document _document;
             private readonly INamedTypeSymbol _containingType;
             private readonly IList<ISymbol> _selectedMembers;
             private readonly TextSpan _textSpan;
 
             public GenerateEqualsAndHashCodeAction(
-                TService service,
+                GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider service,
                 Document document,
                 TextSpan textSpan,
                 INamedTypeSymbol containingType,
@@ -95,4 +95,4 @@ public override string Title
             }
         }
     }
-}
+}
\ No newline at end of file

src/Features/Core/Portable/GenerateFromMembers/AbstractGenerateFromMembersService.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeGeneration;
+using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.GenerateFromMembers
 {
-    internal abstract class AbstractGenerateFromMembersService<TMemberDeclarationSyntax>
-        where TMemberDeclarationSyntax : SyntaxNode
+    internal interface IGenerateFromMembersHelperService : ILanguageService
     {
-        protected AbstractGenerateFromMembersService()
+        Task<ImmutableArray<SyntaxNode>> GetSelectedMembersAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken);
+        IEnumerable<ISymbol> GetDeclaredSymbols(SemanticModel semanticModel, SyntaxNode memberDeclaration, CancellationToken cancellationToken);
+    }
+
+    internal abstract class AbstractGenerateFromMembersCodeRefactoringProvider : CodeRefactoringProvider
+    {
+        protected AbstractGenerateFromMembersCodeRefactoringProvider()
         {
         }
 
-        protected abstract Task<IList<TMemberDeclarationSyntax>> GetSelectedMembersAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken);
-        protected abstract IEnumerable<ISymbol> GetDeclaredSymbols(SemanticModel semanticModel, TMemberDeclarationSyntax memberDeclaration, CancellationToken cancellationToken);
-
         protected class SelectedMemberInfo
         {
             public INamedTypeSymbol ContainingType;
-            public IList<TMemberDeclarationSyntax> SelectedDeclarations;
+            public IList<SyntaxNode> SelectedDeclarations;
             public IList<ISymbol> SelectedMembers;
         }
 
         protected async Task<SelectedMemberInfo> GetSelectedMemberInfoAsync(
             Document document, TextSpan textSpan, CancellationToken cancellationToken)
         {
-            var selectedDeclarations = await this.GetSelectedMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
+            var helper = document.GetLanguageService<IGenerateFromMembersHelperService>();
+
+            var selectedDeclarations = await helper.GetSelectedMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
 
-            if (selectedDeclarations.Count > 0)
+            if (selectedDeclarations.Length > 0)
             {
                 var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
                 var selectedMembers = selectedDeclarations.SelectMany(
-                    d => this.GetDeclaredSymbols(semanticModel, d, cancellationToken)).WhereNotNull().ToList();
+                    d => helper.GetDeclaredSymbols(semanticModel, d, cancellationToken)).WhereNotNull().ToList();
                 if (selectedMembers.Count > 0)
                 {
                     var containingType = selectedMembers.First().ContainingType;
@@ -146,4 +153,4 @@ where constructorTypes.SequenceEqual(symbolTypes)
                 parameterOptions: SymbolDisplayParameterOptions.IncludeParamsRefOut | SymbolDisplayParameterOptions.IncludeType,
                 miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
     }
-}
+}
\ No newline at end of file

src/Features/Core/Portable/GenerateFromMembers/AddConstructorParameters/IAddConstructorParametersService.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Immutable;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeActions;
-using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Text;
-
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.AddConstructorParameters
-{
-    internal interface IAddConstructorParametersService : ILanguageService
-    {
-        Task<ImmutableArray<CodeAction>> AddConstructorParametersAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken);
-    }
-}
\ No newline at end of file

src/Features/Core/Portable/GenerateFromMembers/GenerateConstructorFromMembers/IGenerateConstructorFromMembersService.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Immutable;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeActions;
-using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Text;
-
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
-{
-    internal interface IGenerateConstructorFromMembersService : ILanguageService
-    {
-        Task<ImmutableArray<CodeAction>> GenerateConstructorFromMembersAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken);
-    }
-}
\ No newline at end of file

src/Features/Core/Portable/GenerateFromMembers/GenerateEqualsAndGetHashCode/IGenerateEqualsAndGetHashCodeService.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Immutable;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeActions;
-using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Text;
-
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateEqualsAndGetHashCode
-{
-    internal interface IGenerateEqualsAndGetHashCodeService : ILanguageService
-    {
-        Task<ImmutableArray<CodeAction>> GenerateEqualsAndGetHashCodeAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken);
-    }
-}
\ No newline at end of file

src/Features/VisualBasic/Portable/BasicFeatures.vbproj

@@ -320,9 +320,6 @@
     <Compile Include="ExtractMethod\VisualBasicSyntaxTriviaServiceFactory.vb" />
     <Compile Include="Structure\Providers\ForBlockStructureProvider.vb" />
     <Compile Include="Structure\Providers\ForEachBlockStructureProvider.vb" />
-    <Compile Include="GenerateFromMembers\AddConstructorParameters\VisualBasicAddConstructorParametersService.vb" />
-    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\VisualBasicGenerateConstructorFromMembersService.vb" />
-    <Compile Include="GenerateFromMembers\GenerateEqualsAndGetHashCode\VisualBasicGenerateEqualsAndGetHashCodeService.vb" />
     <Compile Include="GenerateFromMembers\GenerateFromMembersHelpers.vb" />
     <Compile Include="GenerateConstructor\VisualBasicGenerateConstructorService.vb" />
     <Compile Include="GenerateMember\GenerateDefaultConstructors\VisualBasicGenerateDefaultConstructorsService.vb" />

src/Features/VisualBasic/Portable/GenerateFromMembers/AddConstructorParameters/VisualBasicAddConstructorParametersService.vb

-' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-Imports System.Composition
-Imports System.Threading
-Imports Microsoft.CodeAnalysis.GenerateFromMembers.AddConstructorParameters
-Imports Microsoft.CodeAnalysis.Host.Mef
-Imports Microsoft.CodeAnalysis.Text
-Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
-
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.GenerateFromMembers.AddConstructorParameters
-    <ExportLanguageService(GetType(IAddConstructorParametersService), LanguageNames.VisualBasic), [Shared]>
-    Friend Class VisualBasicAddConstructorParametersService
-        Inherits AbstractAddConstructorParametersService(Of VisualBasicAddConstructorParametersService, StatementSyntax)
-
-        Protected Overloads Overrides Function GetSelectedMembersAsync(
-                document As Document, textSpan As TextSpan, cancellationToken As CancellationToken) As Task(Of IList(Of StatementSyntax))
-            Return GenerateFromMembersHelpers.GetSelectedMembersAsync(document, textSpan, cancellationToken)
-        End Function
-
-        Protected Overrides Function GetDeclaredSymbols(
-                semanticModel As SemanticModel,
-                memberDeclaration As StatementSyntax,
-                cancellationToken As CancellationToken) As IEnumerable(Of ISymbol)
-            Return GenerateFromMembersHelpers.GetDeclaredSymbols(semanticModel, memberDeclaration, cancellationToken)
-        End Function
-    End Class
-End Namespace

src/Features/VisualBasic/Portable/GenerateFromMembers/GenerateConstructorFromMembers/VisualBasicGenerateConstructorFromMembersService.vb

-' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-Imports System.Composition
-Imports System.Threading
-Imports Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
-Imports Microsoft.CodeAnalysis.Host.Mef
-Imports Microsoft.CodeAnalysis.Text
-Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
-
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.GenerateFromMembers.GenerateConstructorFromMembers
-    <ExportLanguageService(GetType(IGenerateConstructorFromMembersService), LanguageNames.VisualBasic), [Shared]>
-    Friend Class VisualBasicGenerateConstructorFromMembersService
-        Inherits AbstractGenerateConstructorFromMembersService(Of VisualBasicGenerateConstructorFromMembersService, StatementSyntax)
-
-        Protected Overloads Overrides Async Function GetSelectedMembersAsync(
-                document As Document, textSpan As TextSpan, cancellationToken As CancellationToken) As Task(Of IList(Of StatementSyntax))
-
-            If cancellationToken.IsCancellationRequested Then
-                Return SpecializedCollections.EmptyList(Of StatementSyntax)()
-            Else
-                Return Await GenerateFromMembersHelpers.GetSelectedMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(False)
-            End If
-        End Function
-
-        Protected Overrides Function GetDeclaredSymbols(
-                semanticModel As SemanticModel,
-                memberDeclaration As StatementSyntax,
-                cancellationToken As CancellationToken) As IEnumerable(Of ISymbol)
-            Return GenerateFromMembersHelpers.GetDeclaredSymbols(semanticModel, memberDeclaration, cancellationToken)
-        End Function
-    End Class
-End Namespace

src/Features/VisualBasic/Portable/GenerateFromMembers/GenerateEqualsAndGetHashCode/VisualBasicGenerateEqualsAndGetHashCodeService.vb

-' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-Imports System.Composition
-Imports System.Threading
-Imports Microsoft.CodeAnalysis.GenerateFromMembers.GenerateEqualsAndGetHashCode
-Imports Microsoft.CodeAnalysis.Host.Mef
-Imports Microsoft.CodeAnalysis.Text
-Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
-
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.GenerateFromMembers.GenerateEqualsAndGetHashCode
-    <ExportLanguageService(GetType(IGenerateEqualsAndGetHashCodeService), LanguageNames.VisualBasic), [Shared]>
-    Friend Class VisualBasicGenerateEqualsAndGetHashCodeService
-        Inherits AbstractGenerateEqualsAndGetHashCodeService(Of VisualBasicGenerateEqualsAndGetHashCodeService, StatementSyntax)
-
-        Protected Overloads Overrides Async Function GetSelectedMembersAsync(
-                document As Document, textSpan As TextSpan, cancellationToken As CancellationToken) As Task(Of IList(Of StatementSyntax))
-
-            If cancellationToken.IsCancellationRequested Then
-                Return SpecializedCollections.EmptyList(Of StatementSyntax)()
-            Else
-                Return Await GenerateFromMembersHelpers.GetSelectedMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(False)
-            End If
-        End Function
-
-        Protected Overrides Function GetDeclaredSymbols(
-                semanticModel As SemanticModel,
-                memberDeclaration As StatementSyntax,
-                cancellationToken As CancellationToken) As IEnumerable(Of ISymbol)
-            Return GenerateFromMembersHelpers.GetDeclaredSymbols(semanticModel, memberDeclaration, cancellationToken)
-        End Function
-    End Class
-End Namespace

src/Features/VisualBasic/Portable/GenerateFromMembers/GenerateFromMembersHelpers.vb

 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+Imports System.Composition
 Imports System.Threading
 Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
+Imports Microsoft.CodeAnalysis.GenerateFromMembers
+Imports System.Collections.Immutable
+Imports Microsoft.CodeAnalysis.Host.Mef
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.GenerateFromMembers
-    Friend Class GenerateFromMembersHelpers
-        Public Shared Async Function GetSelectedMembersAsync(
-                document As Document, textSpan As TextSpan, cancellationToken As CancellationToken) As Task(Of IList(Of StatementSyntax))
+    <ExportLanguageService(GetType(IGenerateFromMembersHelperService), LanguageNames.VisualBasic), [Shared]>
+    Friend Class VisualBasicGenerateFromMembersHelpersService
+        Implements IGenerateFromMembersHelperService
+
+        Public Async Function GetSelectedMembersAsync(
+                document As Document, textSpan As TextSpan, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of SyntaxNode)) Implements IGenerateFromMembersHelperService.GetSelectedMembersAsync
             Dim tree = Await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(False)
-            Return tree.GetMembersInSpan(textSpan, cancellationToken)
+            Return ImmutableArray(Of SyntaxNode).CastUp(tree.GetMembersInSpan(textSpan, cancellationToken))
         End Function
 
-        Public Shared Function GetDeclaredSymbols(semanticModel As SemanticModel, memberDeclaration As StatementSyntax, cancellationToken As CancellationToken) As IEnumerable(Of ISymbol)
+        Public Function GetDeclaredSymbols(semanticModel As SemanticModel, memberDeclaration As SyntaxNode, cancellationToken As CancellationToken) As IEnumerable(Of ISymbol) Implements IGenerateFromMembersHelperService.GetDeclaredSymbols
             If TypeOf memberDeclaration Is FieldDeclarationSyntax Then
                 Return DirectCast(memberDeclaration, FieldDeclarationSyntax).Declarators.
                     SelectMany(Function(d) d.Names.AsEnumerable()).

src/Workspaces/CSharp/Portable/Extensions/SyntaxTreeExtensions.cs

@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp;
@@ -499,7 +500,7 @@ private static bool AtEndOfIncompleteStringOrCharLiteral(SyntaxToken token, int
             return false;
         }
 
-        public static IList<MemberDeclarationSyntax> GetMembersInSpan(
+        public static ImmutableArray<MemberDeclarationSyntax> GetMembersInSpan(
             this SyntaxTree syntaxTree,
             TextSpan textSpan,
             CancellationToken cancellationToken)
@@ -511,50 +512,52 @@ private static bool AtEndOfIncompleteStringOrCharLiteral(SyntaxToken token, int
                 var containingType = firstMember.Parent as TypeDeclarationSyntax;
                 if (containingType != null)
                 {
-                    var members = GetMembersInSpan(textSpan, containingType, firstMember);
-                    if (members != null)
-                    {
-                        return members;
-                    }
+                    return GetMembersInSpan(textSpan, containingType, firstMember);
                 }
             }
 
-            return SpecializedCollections.EmptyList<MemberDeclarationSyntax>();
+            return ImmutableArray<MemberDeclarationSyntax>.Empty;
         }
 
-        private static List<MemberDeclarationSyntax> GetMembersInSpan(
+        private static ImmutableArray<MemberDeclarationSyntax> GetMembersInSpan(
             TextSpan textSpan,
             TypeDeclarationSyntax containingType,
             MemberDeclarationSyntax firstMember)
         {
-            List<MemberDeclarationSyntax> selectedMembers = null;
-
-            var members = containingType.Members;
-            var fieldIndex = members.IndexOf(firstMember);
-            if (fieldIndex < 0)
+            var selectedMembers = ArrayBuilder<MemberDeclarationSyntax>.GetInstance();
+            try
             {
-                return null;
-            }
 
-            for (var i = fieldIndex; i < members.Count; i++)
-            {
-                var member = members[i];
-                if (textSpan.Contains(member.Span))
+                var members = containingType.Members;
+                var fieldIndex = members.IndexOf(firstMember);
+                if (fieldIndex < 0)
                 {
-                    selectedMembers = selectedMembers ?? new List<MemberDeclarationSyntax>();
-                    selectedMembers.Add(member);
+                    return ImmutableArray<MemberDeclarationSyntax>.Empty;
                 }
-                else if (textSpan.OverlapsWith(member.Span))
-                {
-                    return null;
-                }
-                else
+
+                for (var i = fieldIndex; i < members.Count; i++)
                 {
-                    break;
+                    var member = members[i];
+                    if (textSpan.Contains(member.Span))
+                    {
+                        selectedMembers.Add(member);
+                    }
+                    else if (textSpan.OverlapsWith(member.Span))
+                    {
+                        return ImmutableArray<MemberDeclarationSyntax>.Empty;
+                    }
+                    else
+                    {
+                        break;
+                    }
                 }
-            }
 
-            return selectedMembers;
+                return selectedMembers.ToImmutable();
+            }
+            finally
+            {
+                selectedMembers.Free();
+            }
         }
 
         public static bool IsInPartiallyWrittenGeneric(

src/Workspaces/Core/Portable/Log/FunctionId.cs

@@ -162,8 +162,8 @@ internal enum FunctionId
         Refactoring_CodeRefactoringService_GetRefactoringsAsync,
         Refactoring_AddImport,
         Refactoring_FullyQualify,
-        Refactoring_GenerateFromMembers_AddConstructorParameters,
-        Refactoring_GenerateFromMembers_GenerateConstructor,
+        Refactoring_GenerateFromMembers_AddConstructorParametersFromMembers,
+        Refactoring_GenerateFromMembers_GenerateConstructorFromMembers,
         Refactoring_GenerateFromMembers_GenerateEqualsAndGetHashCode,
         Refactoring_GenerateMember_GenerateConstructor,
         Refactoring_GenerateMember_GenerateDefaultConstructors,

src/Workspaces/VisualBasic/Portable/Extensions/SyntaxTreeExtensions.vb

@@ -15,6 +15,7 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 Imports Microsoft.CodeAnalysis.VisualBasic.Utilities
 Imports Microsoft.CodeAnalysis.Shared.Extensions
+Imports System.Collections.Immutable
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions
     Friend Module SyntaxTreeExtensions
@@ -254,7 +255,7 @@ recurse:
         Public Function GetMembersInSpan(
             syntaxTree As SyntaxTree,
             textSpan As TextSpan,
-            cancellationToken As CancellationToken) As IList(Of StatementSyntax)
+            cancellationToken As CancellationToken) As ImmutableArray(Of StatementSyntax)
 
             Dim token = syntaxTree.GetRoot(cancellationToken).FindToken(textSpan.Start)
             Dim firstMember = token.GetAncestors(Of StatementSyntax).
@@ -265,41 +266,41 @@ recurse:
                 If containingType IsNot Nothing AndAlso
                    firstMember IsNot containingType.BlockStatement AndAlso
                    firstMember IsNot containingType.EndBlockStatement Then
-                    Dim members = GetMembersInSpan(textSpan, containingType, firstMember)
-                    If members IsNot Nothing Then
-                        Return members
-                    End If
+                    Return GetMembersInSpan(textSpan, containingType, firstMember)
                 End If
             End If
 
-            Return SpecializedCollections.EmptyList(Of StatementSyntax)()
+            Return ImmutableArray(Of StatementSyntax).Empty
         End Function
 
         Private Function GetMembersInSpan(
             textSpan As TextSpan,
             containingType As TypeBlockSyntax,
-            firstMember As StatementSyntax) As List(Of StatementSyntax)
-            Dim selectedMembers As List(Of StatementSyntax) = Nothing
-
-            Dim members = containingType.Members
-            Dim fieldIndex = members.IndexOf(firstMember)
-            If fieldIndex < 0 Then
-                Return Nothing
-            End If
-
-            For i = fieldIndex To members.Count - 1
-                Dim member = members(i)
-                If textSpan.Contains(member.Span) Then
-                    selectedMembers = If(selectedMembers, New List(Of StatementSyntax))
-                    selectedMembers.Add(member)
-                ElseIf (textSpan.OverlapsWith(member.Span)) Then
-                    Return Nothing
-                Else
-                    Exit For
+            firstMember As StatementSyntax) As ImmutableArray(Of StatementSyntax)
+            Dim selectedMembers = ArrayBuilder(Of StatementSyntax).GetInstance()
+
+            Try
+                Dim members = containingType.Members
+                Dim fieldIndex = members.IndexOf(firstMember)
+                If fieldIndex < 0 Then
+                    Return ImmutableArray(Of StatementSyntax).Empty
                 End If
-            Next
 
-            Return selectedMembers
+                For i = fieldIndex To members.Count - 1
+                    Dim member = members(i)
+                    If textSpan.Contains(member.Span) Then
+                        selectedMembers.Add(member)
+                    ElseIf (textSpan.OverlapsWith(member.Span)) Then
+                        Return ImmutableArray(Of StatementSyntax).Empty
+                    Else
+                        Exit For
+                    End If
+                Next
+
+                Return selectedMembers.ToImmutable()
+            Finally
+                selectedMembers.Free()
+            End Try
         End Function
 
         <Extension()>