Merge pull request #11738 from CyrusNajmabadi/generateConstructorFromMembers

Rename feature name internally.

src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj

@@ -149,7 +149,7 @@
     <Compile Include="CodeActions\ExtractMethod\ExtractMethodTests.cs" />
     <Compile Include="CodeActions\GenerateDefaultConstructors\GenerateDefaultConstructorsTests.cs" />
     <Compile Include="CodeActions\GenerateFromMembers\AddConstructorParameters\AddConstructorParametersTests.cs" />
-    <Compile Include="CodeActions\GenerateFromMembers\GenerateConstructor\GenerateConstructorTests.cs" />
+    <Compile Include="CodeActions\GenerateFromMembers\GenerateConstructorFromMembers\GenerateConstructorFromMembersTests.cs" />
     <Compile Include="CodeActions\GenerateFromMembers\GenerateEqualsAndGetHashCode\GenerateEqualsAndGetHashCodeTests.cs" />
     <Compile Include="CodeActions\InlineTemporary\InlineTemporaryTests.cs" />
     <Compile Include="CodeActions\IntroduceVariable\IntroduceVariableTests.cs" />

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

@@ -3,21 +3,21 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.CodeRefactorings.GenerateFromMembers.GenerateConstructor;
+using Microsoft.CodeAnalysis.CSharp.CodeRefactorings.GenerateFromMembers.GenerateConstructorFromMembers;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
 
-namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.GenerateFromMembers.GenerateConstructor
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.GenerateFromMembers.GenerateConstructorFromMembers
 {
-    public class GenerateConstructorTests : AbstractCSharpCodeActionTest
+    public class GenerateConstructorFromMembersTests : AbstractCSharpCodeActionTest
     {
         protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace)
         {
-            return new GenerateConstructorCodeRefactoringProvider();
+            return new GenerateConstructorFromMembersCodeRefactoringProvider();
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestSingleField()
         {
             await TestAsync(
@@ -26,7 +26,7 @@ public async Task TestSingleField()
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestMultipleFields()
         {
             await TestAsync(
@@ -35,7 +35,7 @@ public async Task TestMultipleFields()
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestSecondField()
         {
             await TestAsync(
@@ -44,7 +44,7 @@ public async Task TestSecondField()
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestFieldAssigningConstructor()
         {
             await TestAsync(
@@ -53,7 +53,7 @@ public async Task TestFieldAssigningConstructor()
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestFieldAssigningConstructor2()
         {
             await TestAsync(
@@ -62,7 +62,7 @@ public async Task TestFieldAssigningConstructor2()
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestDelegatingConstructor()
         {
             await TestAsync(
@@ -71,14 +71,14 @@ public async Task TestDelegatingConstructor()
 index: 1);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestMissingWithExistingConstructor()
         {
             await TestMissingAsync(
 @"using System . Collections . Generic ; class Z { [|int a ; string b ;|] public Z ( int a ) { this . a = a ; } public Z ( int a , string b ) { this . a = a ; this . b = b ; } } ");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestMultipleProperties()
         {
             await TestAsync(
@@ -87,7 +87,7 @@ public async Task TestMultipleProperties()
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestMultiplePropertiesWithQualification()
         {
             await TestAsync(
@@ -96,7 +96,7 @@ public async Task TestMultiplePropertiesWithQualification()
 index: 0, options: Option(CodeStyleOptions.QualifyPropertyAccess, true, NotificationOption.Error));
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestStruct()
         {
             await TestAsync(
@@ -105,7 +105,7 @@ public async Task TestStruct()
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestStruct1()
         {
             await TestAsync(
@@ -114,7 +114,7 @@ public async Task TestStruct1()
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestStruct2()
         {
             await TestAsync(
@@ -123,7 +123,7 @@ public async Task TestStruct2()
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestStruct3()
         {
             await TestAsync(
@@ -132,7 +132,7 @@ public async Task TestStruct3()
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestGenericType()
         {
             await TestAsync(
@@ -141,7 +141,7 @@ public async Task TestGenericType()
 index: 0);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestSmartTagText1()
         {
             await TestSmartTagTextAsync(
@@ -149,7 +149,7 @@ public async Task TestSmartTagText1()
 string.Format(FeaturesResources.GenerateConstructor, "Program", "bool, HashSet<string>"));
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestSmartTagText2()
         {
             await TestSmartTagTextAsync(
@@ -157,7 +157,7 @@ public async Task TestSmartTagText2()
 string.Format(FeaturesResources.GenerateFieldAssigningConstructor, "Program", "bool, HashSet<string>"));
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestSmartTagText3()
         {
             await TestSmartTagTextAsync(
@@ -166,7 +166,7 @@ public async Task TestSmartTagText3()
 index: 1);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestContextualKeywordName()
         {
             await TestAsync(
@@ -174,7 +174,7 @@ public async Task TestContextualKeywordName()
 @"class Program { int yield ; public Program ( int yield ) { this . yield = yield ; } } ");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task TestGenerateConstructorNotOfferedForDuplicate()
         {
             await TestMissingAsync(
@@ -182,7 +182,7 @@ public async Task TestGenerateConstructorNotOfferedForDuplicate()
         }
 
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)]
         public async Task Tuple()
         {
             await TestAsync(

src/EditorFeatures/TestUtilities/Traits.cs

@@ -42,6 +42,7 @@ public static class Features
             public const string CodeActionsCorrectFunctionReturnType = "CodeActions.CorrectFunctionReturnType";
             public const string CodeActionsCorrectNextControlVariable = "CodeActions.CorrectNextControlVariable";
             public const string CodeActionsGenerateConstructor = "CodeActions.GenerateConstructor";
+            public const string CodeActionsGenerateConstructorFromMembers = "CodeActions.GenerateConstructorFromMembers";
             public const string CodeActionsGenerateDefaultConstructors = "CodeActions.GenerateDefaultConstructors";
             public const string CodeActionsGenerateEndConstruct = "CodeActions.GenerateEndConstruct";
             public const string CodeActionsGenerateEnumMember = "CodeActions.GenerateEnumMember";

src/EditorFeatures/VisualBasicTest/BasicEditorServicesTest.vbproj

@@ -130,7 +130,7 @@
     <Compile Include="CodeActions\ExtractMethod\ExtractMethodTests.vb" />
     <Compile Include="CodeActions\GenerateDefaultConstructors\GenerateDefaultConstructorsTests.vb" />
     <Compile Include="CodeActions\GenerateFromMembers\AddConstructorParameters\AddConstructorParametersTests.vb" />
-    <Compile Include="CodeActions\GenerateFromMembers\GenerateConstructor\GenerateConstructorTests.vb" />
+    <Compile Include="CodeActions\GenerateFromMembers\GenerateConstructorFromMembers\GenerateConstructorFromMembersTests.vb" />
     <Compile Include="CodeActions\GenerateFromMembers\GenerateEqualsAndGetHashCode\GenerateEqualsAndGetHashCodeTests.vb" />
     <Compile Include="CodeActions\InlineTemporary\InlineTemporaryTests.vb" />
     <Compile Include="CodeActions\IntroduceVariable\IntroduceVariableTests.vb" />

src/EditorFeatures/VisualBasicTest/CodeActions/GenerateFromMembers/AddConstructorParameters/AddConstructorParametersTests.vb

@@ -10,7 +10,7 @@ Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.GenerateFromMembers.AddConstructorParameters
 Imports Roslyn.Test.Utilities
 
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings.GenerateFromMembers
+Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings.GenerateConstructorFromMembers
     Public Class AddConstructorParameterTests
         Inherits AbstractVisualBasicCodeActionTest
 

src/EditorFeatures/VisualBasicTest/CodeActions/GenerateFromMembers/GenerateConstructor/GenerateConstructorTests.vb → src/EditorFeatures/VisualBasicTest/CodeActions/GenerateFromMembers/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.
 
 Option Strict Off
-
-Imports System.Threading.Tasks
-Imports Microsoft.CodeAnalysis.CodeGeneration
 Imports Microsoft.CodeAnalysis.CodeRefactorings
-Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
-Imports Microsoft.CodeAnalysis.Text
-Imports Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.GenerateFromMembers.GenerateConstructor
-Imports Roslyn.Test.Utilities
+Imports Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.GenerateFromMembers.GenerateConstructorFromMembers
 
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings.GenerateFromMembers
-    Public Class GenerateConstructorTests
+Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings.GenerateConstructorFromMembers
+    Public Class GenerateConstructorFromMembersTests
         Inherits AbstractVisualBasicCodeActionTest
 
         Protected Overrides Function CreateCodeRefactoringProvider(workspace As Workspace) As CodeRefactoringProvider
-            Return New GenerateConstructorCodeRefactoringProvider()
+            Return New GenerateConstructorFromMembersCodeRefactoringProvider()
         End Function
 
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)>
         Public Async Function TestSingleField() As Task
             Await TestAsync(
 NewLines("Class Program \n [|Private i As Integer|] \n End Class"),
@@ -26,7 +20,7 @@ NewLines("Class Program \n Private i As Integer \n Public Sub New(i As Integer)
 index:=0)
         End Function
 
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)>
         Public Async Function TestMultipleFields() As Task
             Await TestAsync(
 NewLines("Class Program \n [|Private i As Integer \n Private b As String|] \n End Class"),
@@ -34,7 +28,7 @@ NewLines("Class Program \n Private i As Integer \n Private b As String \n Public
 index:=0)
         End Function
 
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)>
         Public Async Function TestSecondField() As Task
             Await TestAsync(
 NewLines("Class Program \n Private i As Integer \n [|Private b As String|] \n Public Sub New(i As Integer) \n Me.i = i \n End Sub \n End Class"),
@@ -42,7 +36,7 @@ NewLines("Class Program \n Private i As Integer \n Private b As String \n Public
 index:=0)
         End Function
 
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)>
         Public Async Function TestFieldAssigningConstructor() As Task
             Await TestAsync(
 NewLines("Class Program \n [|Private i As Integer \n Private b As String|] \n Public Sub New(i As Integer) \n Me.i = i \n End Sub \n End Class"),
@@ -50,13 +44,13 @@ NewLines("Class Program \n Private i As Integer \n Private b As String \n Public
 index:=0)
         End Function
 
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)>
         Public Async Function TestMissingWithExistingConstructor() As Task
             Await TestMissingAsync(
 NewLines("Class Program \n [|Private i As Integer \n Private b As String|] \n Public Sub New(i As Integer) \n Me.i = i \n End Sub \n Public Sub New(i As Integer, b As String) \n Me.i = i \n Me.b = b \n End Sub \n End Class"))
         End Function
 
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)>
         Public Async Function TestStruct() As Task
             Await TestAsync(
 NewLines("Structure S \n [|Private i As Integer|] \n End Structure"),
@@ -64,7 +58,7 @@ NewLines("Structure S \n Private i As Integer \n Public Sub New(i As Integer) \n
 index:=0)
         End Function
 
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)>
         Public Async Function TestGenericType() As Task
             Await TestAsync(
 NewLines("Class Program ( Of T ) \n [|Private i As Integer|] \n End Class"),
@@ -73,7 +67,7 @@ index:=0)
         End Function
 
         <WorkItem(541995, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541995")>
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)>
         Public Async Function TestSimpleDelegatingConstructor() As Task
             Await TestAsync(
 NewLines("Class Program \n [|Private i As Integer \n Private b As String|] \n Public Sub New(i As Integer) \n Me.i = i \n End Sub \n End Class"),
@@ -82,7 +76,7 @@ index:=1)
         End Function
 
         <WorkItem(542008, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542008")>
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)>
         Public Async Function TestGenerateFromNormalProperties() As Task
             Await TestAsync(
 NewLines("Class Z \n [|Public Property A As Integer \n Public Property B As String|] \n End Class"),

src/EditorFeatures/VisualBasicTest/CodeActions/GenerateFromMembers/GenerateEqualsAndGetHashCode/GenerateEqualsAndGetHashCodeTests.vb

@@ -10,7 +10,7 @@ Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.GenerateFromMembers.GenerateEqualsAndGetHashCode
 Imports Roslyn.Test.Utilities
 
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings.GenerateFromMembers
+Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings.GenerateConstructorFromMembers
     Public Class GenerateEqualsAndGetHashCodeTests
         Inherits AbstractVisualBasicCodeActionTest
 

src/Features/CSharp/Portable/CSharpFeatures.csproj

@@ -97,7 +97,7 @@
     <Compile Include="CodeRefactorings\ExtractMethod\ExtractMethodCodeRefactoringProvider.cs" />
     <Compile Include="CodeRefactorings\GenerateDefaultConstructors\GenerateDefaultConstructorsCodeRefactoringProvider.cs" />
     <Compile Include="CodeRefactorings\GenerateFromMembers\AddConstructorParameters\AddConstructorParametersCodeRefactoringProvider.cs" />
-    <Compile Include="CodeRefactorings\GenerateFromMembers\GenerateConstructor\GenerateConstructorCodeRefactoringProvider.cs" />
+    <Compile Include="CodeRefactorings\GenerateFromMembers\GenerateConstructorFromMembers\GenerateConstructorFromMembersCodeRefactoringProvider.cs" />
     <Compile Include="CodeRefactorings\GenerateFromMembers\GenerateEqualsAndGetHashCode\GenerateEqualsAndGetHashCodeCodeRefactoringProvider.cs" />
     <Compile Include="CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.cs" />
     <Compile Include="CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.InitializerRewriter.cs" />
@@ -305,7 +305,7 @@
     <Compile Include="ExtractMethod\CSharpSyntaxTriviaServiceFactory.cs" />
     <Compile Include="ExtractMethod\Extensions.cs" />
     <Compile Include="GenerateFromMembers\AddConstructorParameters\CSharpAddConstructorParametersService.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructor\CSharpGenerateConstructorService.cs" />
+    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\CSharpGenerateConstructorFromMembersService.cs" />
     <Compile Include="GenerateFromMembers\GenerateEqualsAndGetHashCode\CSharpGenerateEqualsAndGetHashCodeService.cs" />
     <Compile Include="GenerateFromMembers\GenerateFromMembersHelpers.cs" />
     <Compile Include="GenerateMember\GenerateConstructor\CSharpGenerateConstructorService.cs" />

src/Features/CSharp/Portable/CodeRefactorings/GenerateFromMembers/GenerateConstructor/GenerateConstructorCodeRefactoringProvider.cs → src/Features/CSharp/Portable/CodeRefactorings/GenerateFromMembers/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs

@@ -3,14 +3,14 @@
 using System.Composition;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructor;
+using Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 
-namespace Microsoft.CodeAnalysis.CSharp.CodeRefactorings.GenerateFromMembers.GenerateConstructor
+namespace Microsoft.CodeAnalysis.CSharp.CodeRefactorings.GenerateFromMembers.GenerateConstructorFromMembers
 {
     [ExportCodeRefactoringProvider(LanguageNames.CSharp, Name = PredefinedCodeRefactoringProviderNames.GenerateConstructorFromMembers), Shared]
     [ExtensionOrder(Before = PredefinedCodeRefactoringProviderNames.AddConstructorParametersFromMembers)]
-    internal class GenerateConstructorCodeRefactoringProvider : CodeRefactoringProvider
+    internal class GenerateConstructorFromMembersCodeRefactoringProvider : CodeRefactoringProvider
     {
         public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
         {
@@ -23,8 +23,8 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                 return;
             }
 
-            var service = document.GetLanguageService<IGenerateConstructorService>();
-            var result = await service.GenerateConstructorAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
+            var service = document.GetLanguageService<IGenerateConstructorFromMembersService>();
+            var result = await service.GenerateConstructorFromMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
 
             if (!result.ContainsChanges)
             {

src/Features/CSharp/Portable/GenerateFromMembers/GenerateConstructor/CSharpGenerateConstructorService.cs → src/Features/CSharp/Portable/GenerateFromMembers/GenerateConstructorFromMembers/CSharpGenerateConstructorFromMembersService.cs

@@ -5,16 +5,15 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructor;
-using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.CSharp.GenerateFromMembers.GenerateConstructor
+namespace Microsoft.CodeAnalysis.CSharp.GenerateFromMembers.GenerateConstructorFromMembers
 {
-    [ExportLanguageService(typeof(IGenerateConstructorService), LanguageNames.CSharp), Shared]
-    internal class CSharpGenerateConstructorService :
-        AbstractGenerateConstructorService<CSharpGenerateConstructorService, MemberDeclarationSyntax>
+    [ExportLanguageService(typeof(IGenerateConstructorFromMembersService), LanguageNames.CSharp), Shared]
+    internal class CSharpGenerateConstructorFromMembersService :
+        AbstractGenerateConstructorFromMembersService<CSharpGenerateConstructorFromMembersService, MemberDeclarationSyntax>
     {
         protected override Task<IList<MemberDeclarationSyntax>> GetSelectedMembersAsync(
             Document document, TextSpan textSpan, CancellationToken cancellationToken)

src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateMethodService.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;
-using System.Collections.Generic;
 using System.Composition;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
 using Microsoft.CodeAnalysis.CSharp.GenerateMember.GenerateParameterizedMember;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.GenerateMember.GenerateParameterizedMember;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.GenerateMember.GenerateMethod
 {

src/Features/CSharp/Portable/ImplementAbstractClass/CSharpImplementAbstractClassService.cs

@@ -4,7 +4,6 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.ImplementAbstractClass;
 using Microsoft.CodeAnalysis.Shared.Extensions;

src/Features/Core/Portable/Features.csproj

@@ -421,13 +421,13 @@
     <Compile Include="GenerateFromMembers\AddConstructorParameters\AddConstructorParametersResult.cs" />
     <Compile Include="GenerateFromMembers\AddConstructorParameters\IAddConstructorParametersResult.cs" />
     <Compile Include="GenerateFromMembers\AddConstructorParameters\IAddConstructorParametersService.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructor\AbstractGenerateConstructorService.ConstructorDelegatingCodeAction.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructor\AbstractGenerateConstructorService.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructor\AbstractGenerateConstructorService.FieldDelegatingCodeAction.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructor\AbstractGenerateConstructorService.State.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructor\GenerateConstructorResult.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructor\IGenerateConstructorResult.cs" />
-    <Compile Include="GenerateFromMembers\GenerateConstructor\IGenerateConstructorService.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\GenerateConstructorFromMembersResult.cs" />
+    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\IGenerateConstructorFromMembersResult.cs" />
+    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\IGenerateConstructorFromMembersService.cs" />
     <Compile Include="GenerateFromMembers\GenerateEqualsAndGetHashCode\AbstractGenerateEqualsAndGetHashCodeService.cs" />
     <Compile Include="GenerateFromMembers\GenerateEqualsAndGetHashCode\GenerateEqualsAndGetHashCodeCodeRefactoringProvider.CodeAction.cs" />
     <Compile Include="GenerateFromMembers\GenerateEqualsAndGetHashCode\GenerateEqualsAndGetHashCodeResult.cs" />

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

@@ -9,11 +9,10 @@
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
-using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructor
+namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
 {
-    internal abstract partial class AbstractGenerateConstructorService<TService, TMemberDeclarationSyntax>
+    internal abstract partial class AbstractGenerateConstructorFromMembersService<TService, TMemberDeclarationSyntax>
     {
         private class ConstructorDelegatingCodeAction : CodeAction
         {

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

@@ -11,9 +11,9 @@
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructor
+namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
 {
-    internal abstract partial class AbstractGenerateConstructorService<TService, TMemberDeclarationSyntax>
+    internal abstract partial class AbstractGenerateConstructorFromMembersService<TService, TMemberDeclarationSyntax>
     {
         private class FieldDelegatingCodeAction : CodeAction
         {

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

@@ -6,9 +6,9 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructor
+namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
 {
-    internal abstract partial class AbstractGenerateConstructorService<TService, TMemberDeclarationSyntax>
+    internal abstract partial class AbstractGenerateConstructorFromMembersService<TService, TMemberDeclarationSyntax>
     {
         private class State
         {

src/Features/Core/Portable/GenerateFromMembers/GenerateConstructor/AbstractGenerateConstructorService.cs → src/Features/Core/Portable/GenerateFromMembers/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersService.cs

@@ -7,18 +7,18 @@
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructor
+namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
 {
-    internal abstract partial class AbstractGenerateConstructorService<TService, TMemberDeclarationSyntax> :
-            AbstractGenerateFromMembersService<TMemberDeclarationSyntax>, IGenerateConstructorService
-        where TService : AbstractGenerateConstructorService<TService, TMemberDeclarationSyntax>
+    internal abstract partial class AbstractGenerateConstructorFromMembersService<TService, TMemberDeclarationSyntax> :
+            AbstractGenerateFromMembersService<TMemberDeclarationSyntax>, IGenerateConstructorFromMembersService
+        where TService : AbstractGenerateConstructorFromMembersService<TService, TMemberDeclarationSyntax>
         where TMemberDeclarationSyntax : SyntaxNode
     {
-        protected AbstractGenerateConstructorService()
+        protected AbstractGenerateConstructorFromMembersService()
         {
         }
 
-        public async Task<IGenerateConstructorResult> GenerateConstructorAsync(
+        public async Task<IGenerateConstructorFromMembersResult> GenerateConstructorFromMembersAsync(
             Document document, TextSpan textSpan, CancellationToken cancellationToken)
         {
             using (Logger.LogBlock(FunctionId.Refactoring_GenerateFromMembers_GenerateConstructor, cancellationToken))
@@ -29,12 +29,12 @@ protected AbstractGenerateConstructorService()
                     var state = State.Generate((TService)this, document, textSpan, info.ContainingType, info.SelectedMembers, cancellationToken);
                     if (state != null)
                     {
-                        return new GenerateConstructorResult(
+                        return new GenerateConstructorFromMembersResult(
                             CreateCodeRefactoring(info.SelectedDeclarations, GetCodeActions(document, state)));
                     }
                 }
 
-                return GenerateConstructorResult.Failure;
+                return GenerateConstructorFromMembersResult.Failure;
             }
         }
 

src/Features/Core/Portable/GenerateFromMembers/GenerateConstructor/GenerateConstructorResult.cs → src/Features/Core/Portable/GenerateFromMembers/GenerateConstructorFromMembers/GenerateConstructorFromMembersResult.cs

@@ -2,13 +2,13 @@
 
 using Microsoft.CodeAnalysis.CodeRefactorings;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructor
+namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
 {
-    internal class GenerateConstructorResult : AbstractCodeRefactoringResult, IGenerateConstructorResult
+    internal class GenerateConstructorFromMembersResult : AbstractCodeRefactoringResult, IGenerateConstructorFromMembersResult
     {
-        public static readonly IGenerateConstructorResult Failure = new GenerateConstructorResult(null);
+        public static readonly IGenerateConstructorFromMembersResult Failure = new GenerateConstructorFromMembersResult(null);
 
-        public GenerateConstructorResult(CodeRefactoring codeRefactoring)
+        public GenerateConstructorFromMembersResult(CodeRefactoring codeRefactoring)
             : base(codeRefactoring)
         {
         }

src/Features/Core/Portable/GenerateFromMembers/GenerateConstructor/IGenerateConstructorResult.cs → src/Features/Core/Portable/GenerateFromMembers/GenerateConstructorFromMembers/IGenerateConstructorFromMembersResult.cs

@@ -3,11 +3,11 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructor
+namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
 {
-    internal interface IGenerateConstructorResult
+    internal interface IGenerateConstructorFromMembersResult
     {
         bool ContainsChanges { get; }
         CodeRefactoring GetCodeRefactoring(CancellationToken cancellationToken);
     }
-}
+}
\ No newline at end of file

src/Features/Core/Portable/GenerateFromMembers/GenerateConstructor/IGenerateConstructorService.cs → src/Features/Core/Portable/GenerateFromMembers/GenerateConstructorFromMembers/IGenerateConstructorFromMembersService.cs

@@ -5,10 +5,10 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructor
+namespace Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
 {
-    internal interface IGenerateConstructorService : ILanguageService
+    internal interface IGenerateConstructorFromMembersService : ILanguageService
     {
-        Task<IGenerateConstructorResult> GenerateConstructorAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken);
+        Task<IGenerateConstructorFromMembersResult> GenerateConstructorFromMembersAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken);
     }
 }

src/Features/VisualBasic/Portable/BasicFeatures.vbproj

@@ -131,7 +131,7 @@
     <Compile Include="CodeRefactorings\ExtractMethod\ExtractMethodCodeActionProvider.vb" />
     <Compile Include="CodeRefactorings\GenerateDefaultConstructors\GenerateDefaultConstructorsCodeActionProvider.vb" />
     <Compile Include="CodeRefactorings\GenerateFromMembers\AddConstructorParameters\AddConstructorParametersCodeRefactoringProvider.vb" />
-    <Compile Include="CodeRefactorings\GenerateFromMembers\GenerateConstructor\GenerateConstructorCodeRefactoringProvider.vb" />
+    <Compile Include="CodeRefactorings\GenerateFromMembers\GenerateConstructorFromMembers\GenerateConstructorFromMembersCodeRefactoringProvider.vb" />
     <Compile Include="CodeRefactorings\GenerateFromMembers\GenerateEqualsAndGetHashCode\GenerateEqualsAndGetHashCodeCodeRefactoringProvider.vb" />
     <Compile Include="CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.ReferenceRewriter.vb" />
     <Compile Include="CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.vb" />
@@ -331,7 +331,7 @@
     <Compile Include="ExtractMethod\VisualBasicSyntaxTriviaService.vb" />
     <Compile Include="ExtractMethod\VisualBasicSyntaxTriviaServiceFactory.vb" />
     <Compile Include="GenerateFromMembers\AddConstructorParameters\VisualBasicAddConstructorParametersService.vb" />
-    <Compile Include="GenerateFromMembers\GenerateConstructor\VisualBasicGenerateConstructorService.vb" />
+    <Compile Include="GenerateFromMembers\GenerateConstructorFromMembers\VisualBasicGenerateConstructorFromMembersService.vb" />
     <Compile Include="GenerateFromMembers\GenerateEqualsAndGetHashCode\VisualBasicGenerateEqualsAndGetHashCodeService.vb" />
     <Compile Include="GenerateFromMembers\GenerateFromMembersHelpers.vb" />
     <Compile Include="GenerateMember\GenerateConstructor\VisualBasicGenerateConstructorService.vb" />

src/Features/VisualBasic/Portable/CodeRefactorings/GenerateFromMembers/GenerateConstructor/GenerateConstructorCodeRefactoringProvider.vb → src/Features/VisualBasic/Portable/CodeRefactorings/GenerateFromMembers/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.vb

@@ -2,12 +2,12 @@
 
 Imports System.Composition
 Imports Microsoft.CodeAnalysis.CodeRefactorings
-Imports Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructor
+Imports Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructorFromMembers
 
-Namespace Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.GenerateFromMembers.GenerateConstructor
+Namespace Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.GenerateFromMembers.GenerateConstructorFromMembers
     <ExportCodeRefactoringProvider(LanguageNames.VisualBasic, Name:=PredefinedCodeRefactoringProviderNames.GenerateConstructorFromMembers), [Shared]>
     <ExtensionOrder(Before:=PredefinedCodeRefactoringProviderNames.AddConstructorParametersFromMembers)>
-    Friend Class GenerateConstructorCodeRefactoringProvider
+    Friend Class GenerateConstructorFromMembersCodeRefactoringProvider
         Inherits CodeRefactoringProvider
 
         Public Overrides Async Function ComputeRefactoringsAsync(context As CodeRefactoringContext) As Task
@@ -20,8 +20,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.GenerateFromMember
                 Return
             End If
 
-            Dim service = document.GetLanguageService(Of IGenerateConstructorService)()
-            Dim result = Await service.GenerateConstructorAsync(document, textSpan, cancellationToken).ConfigureAwait(False)
+            Dim service = document.GetLanguageService(Of IGenerateConstructorFromMembersService)()
+            Dim result = Await service.GenerateConstructorFromMembersAsync(document, textSpan, cancellationToken).ConfigureAwait(False)
 
             If Not result.ContainsChanges Then
                 Return

src/Features/VisualBasic/Portable/GenerateFromMembers/GenerateConstructor/VisualBasicGenerateConstructorService.vb → src/Features/VisualBasic/Portable/GenerateFromMembers/GenerateConstructorFromMembers/VisualBasicGenerateConstructorFromMembersService.vb

@@ -2,16 +2,15 @@
 
 Imports System.Composition
 Imports System.Threading
-Imports Microsoft.CodeAnalysis.GenerateFromMembers.GenerateConstructor
-Imports Microsoft.CodeAnalysis.Host
+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.GenerateConstructor
-    <ExportLanguageService(GetType(IGenerateConstructorService), LanguageNames.VisualBasic), [Shared]>
-    Friend Class VisualBasicGenerateConstructorService
-        Inherits AbstractGenerateConstructorService(Of VisualBasicGenerateConstructorService, StatementSyntax)
+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))