diff --git a/src/EditorFeatures/CSharpTest/Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests.csproj b/src/EditorFeatures/CSharpTest/Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests.csproj
index dc60e6da2389412f74fdbf4461ff5354b3a836ec..581e8f3e0c48f722de8ebc6acbbb732a288a7731 100644
--- a/src/EditorFeatures/CSharpTest/Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests.csproj
+++ b/src/EditorFeatures/CSharpTest/Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests.csproj
@@ -80,4 +80,7 @@
+
+
+
\ No newline at end of file
diff --git a/src/EditorFeatures/CSharpTest/MoveToNamespace/MoveToNamespaceTests.cs b/src/EditorFeatures/CSharpTest/MoveToNamespace/MoveToNamespaceTests.cs
deleted file mode 100644
index 559c7e6c411fa27fdfea16ee70f9bd9f241cdc0f..0000000000000000000000000000000000000000
--- a/src/EditorFeatures/CSharpTest/MoveToNamespace/MoveToNamespaceTests.cs
+++ /dev/null
@@ -1,225 +0,0 @@
-// 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.Test.Utilities;
-using Microsoft.CodeAnalysis.Test.Utilities.MoveToNamespace;
-using Roslyn.Test.Utilities;
-using Xunit;
-
-namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.MoveToNamespace
-{
- public class MoveToNamespaceTests : AbstractMoveToNamespaceTests
- {
- [WpfFact, Trait(Traits.Feature, Traits.Features.MoveToNamespace)]
- public async Task MoveToNamespace_CaretOnNamespaceName()
- {
- var markup = @"
-using System;
-
-namespace A$$
-{
- class MyClass
- {
- void Method() { }
- }
-}";
-
- var expectedMarkup = @"
-using System;
-
-namespace B
-{
- class MyClass
- {
- void Method() { }
- }
-}";
- await TestMoveToNamespaceCommandCSharpAsync(
- markup,
- expectedSuccess: true,
- expectedNamespace: "B",
- expectedMarkup: expectedMarkup);
- }
-
- [WpfFact, Trait(Traits.Feature, Traits.Features.MoveToNamespace)]
- public async Task MoveToNamespace_CaretOnNamespaceKeyword()
- {
- var markup = @"
-using System;
-
-namespace$$ A
-{
- class MyClass
- {
- void Method() { }
- }
-}";
-
- var expectedMarkup = @"
-using System;
-
-namespace B
-{
- class MyClass
- {
- void Method() { }
- }
-}";
- await TestMoveToNamespaceCommandCSharpAsync(
- markup,
- expectedSuccess: true,
- expectedNamespace: "B",
- expectedMarkup: expectedMarkup);
- }
-
- [WpfFact, Trait(Traits.Feature, Traits.Features.MoveToNamespace)]
- public async Task MoveToNamespace_CaretOnNamespaceNameMultipleDeclarations()
- {
- var markup = @"
-using System;
-
-namespace A$$
-{
- class MyClass
- {
- void Method() { }
- }
-
- class MyOtherClass
- {
- void Method() { }
- }
-}";
-
- var expectedMarkup = @"
-using System;
-
-namespace B
-{
- class MyClass
- {
- void Method() { }
- }
-
- class MyOtherClass
- {
- void Method() { }
- }
-}";
- await TestMoveToNamespaceCommandCSharpAsync(
- markup,
- expectedSuccess: true,
- expectedNamespace: "B",
- expectedMarkup: expectedMarkup);
- }
-
- [WpfFact, Trait(Traits.Feature, Traits.Features.MoveToNamespace)]
- public async Task MoveToNamespace_CaretOnTypeDeclaration()
- {
- var markup = @"
-using System;
-namespace A
-{
- class MyClass$$
- {
- void Method() {}
- }
-}";
- await TestMoveToNamespaceCommandCSharpAsync(
- markup,
- expectedSuccess: false);
- }
-
- [WpfFact, Trait(Traits.Feature, Traits.Features.MoveToNamespace)]
- public async Task MoveToNamespace_WithVariousSymbols()
- {
- var markup = @"
-using System;
-
-namespace A$$
-{
- public delegate void MyDelegate();
-
- public enum MyEnum
- {
- One,
- Two,
- Three
- }
-
- public struct MyStruct
- { }
-
- public interface MyInterface
- { }
-
- class MyClass
- {
- void Method() { }
- }
-
- class MyOtherClass
- {
- void Method() { }
- }
-}";
-
- var expectedMarkup = @"
-using System;
-
-namespace B
-{
- public delegate void MyDelegate();
-
- public enum MyEnum
- {
- One,
- Two,
- Three
- }
-
- public struct MyStruct
- { }
-
- public interface MyInterface
- { }
-
- class MyClass
- {
- void Method() { }
- }
-
- class MyOtherClass
- {
- void Method() { }
- }
-}";
- await TestMoveToNamespaceCommandCSharpAsync(
- markup,
- expectedSuccess: true,
- expectedNamespace: "B",
- expectedMarkup: expectedMarkup);
- }
-
- [WpfFact, Trait(Traits.Feature, Traits.Features.MoveToNamespace)]
- public async Task MoveToNamespace_NestedNamespace()
- {
- var markup = @"
-using System;
-
-namespace A$$
-{
- namespace C
- {
- class MyClass
- {
- void Method() { }
- }
- }
-}";
- await TestMoveToNamespaceCommandCSharpAsync(
- markup,
- expectedSuccess: false);
- }
- }
-}
diff --git a/src/EditorFeatures/TestUtilities/MoveToNamespace/AbstractMoveToNamespaceTests.cs b/src/EditorFeatures/TestUtilities/MoveToNamespace/AbstractMoveToNamespaceTests.cs
deleted file mode 100644
index 239a60e0978eff9827bd59301992daf3128cb2e2..0000000000000000000000000000000000000000
--- a/src/EditorFeatures/TestUtilities/MoveToNamespace/AbstractMoveToNamespaceTests.cs
+++ /dev/null
@@ -1,146 +0,0 @@
-// 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.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.AddImports;
-using Microsoft.CodeAnalysis.CSharp.ChangeNamespace;
-using Microsoft.CodeAnalysis.CSharp.MoveToNamespace;
-using Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryImports;
-using Microsoft.CodeAnalysis.Editor.UnitTests;
-using Microsoft.CodeAnalysis.Editor.UnitTests.Extensions;
-using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
-using Microsoft.CodeAnalysis.MoveToNamespace;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-using Microsoft.VisualStudio.Composition;
-using Xunit;
-using static Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.AbstractCodeActionOrUserDiagnosticTest;
-
-namespace Microsoft.CodeAnalysis.Test.Utilities.MoveToNamespace
-{
- [UseExportProvider]
- public abstract class AbstractMoveToNamespaceTests
- {
- private static readonly IExportProviderFactory CSharpExportProviderFactory =
- ExportProviderCache.GetOrCreateExportProviderFactory(
- TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic
- .WithPart(typeof(TestMoveToNamespaceOptionsService))
- .WithPart(typeof(CSharpMoveToNamespaceService))
- .WithPart(typeof(CSharpChangeNamespaceService))
- .WithPart(typeof(Experiments.DefaultExperimentationService))
- .WithPart(typeof(CSharpAddImportsService))
- .WithPart(typeof(CSharpRemoveUnnecessaryImportsService)));
-
- public static Task TestMoveToNamespaceCommandCSharpAsync(
- string markup,
- bool expectedSuccess,
- string expectedNamespace = null,
- string expectedMarkup = null)
- {
- return TestMoveToNamespaceCommandAsync(
- markup,
- expectedSuccess,
- LanguageNames.CSharp,
- expectedNamespace: expectedNamespace,
- expectedMarkup: expectedMarkup);
- }
-
- public static Task TestMoveToNamespaceCommandVisualBasicAsync(
- string markup,
- bool expectedSuccess,
- string expectedNamespace = null,
- string expectedMarkup = null)
- {
- return TestMoveToNamespaceCommandAsync(
- markup,
- expectedSuccess,
- LanguageNames.VisualBasic,
- expectedNamespace: expectedNamespace,
- expectedMarkup: expectedMarkup);
- }
-
-
- public static async Task TestMoveToNamespaceCommandAsync(
- string markup,
- bool expectedSuccess,
- string languageName,
- string expectedNamespace = null,
- string expectedMarkup = null,
- CompilationOptions compilationOptions = null)
- {
- expectedNamespace = expectedNamespace ?? string.Empty;
- var parameters = new TestParameters();
- using (var workspace = CreateWorkspace(markup, languageName, compilationOptions, parameters))
- {
- var testDocument = workspace.Documents.Single(d => d.CursorPosition.HasValue);
- var document = workspace.CurrentSolution.GetDocument(testDocument.Id);
-
- var result = await MoveViaCommandAsync(testDocument, document, expectedNamespace);
-
- if (expectedSuccess)
- {
- Assert.True(result.Succeeded);
- Assert.NotNull(result.UpdatedSolution);
- Assert.NotNull(result.UpdatedDocumentId);
-
- if (expectedMarkup != null)
- {
- var updatedDocument = result.UpdatedSolution.GetDocument(result.UpdatedDocumentId);
- var updatedText = await updatedDocument.GetTextAsync().ConfigureAwait(false);
- Assert.Equal(expectedMarkup, updatedText.ToString());
- }
- }
- else
- {
- Assert.False(result.Succeeded);
- }
- }
- }
-
- private static TestWorkspace CreateWorkspace(
- string markup,
- string languageName,
- CompilationOptions compilationOptions,
- TestParameters parameters)
- {
- var exportProviderFactory = GetExportProviderFactory(languageName);
- var exportProvider = exportProviderFactory.CreateExportProvider();
-
- var workspace = languageName == LanguageNames.CSharp
- ? TestWorkspace.CreateCSharp(markup, exportProvider: exportProvider, compilationOptions: compilationOptions as CSharpCompilationOptions)
- : TestWorkspace.CreateVisualBasic(markup, exportProvider: exportProvider, compilationOptions: compilationOptions);
-
- workspace.ApplyOptions(parameters.options);
-
- return workspace;
- }
-
- private static IExportProviderFactory GetExportProviderFactory(string languageName)
- {
- return languageName == LanguageNames.CSharp
- ? CSharpExportProviderFactory
- : throw new InvalidOperationException("VB is not currently supported");
- }
-
- private static async Task MoveViaCommandAsync(
- TestHostDocument testDocument,
- Document document,
- string newNamespace)
- {
- var cancellationToken = CancellationToken.None;
- var moveToNamespaceService = document.GetLanguageService();
-
- var analysisResult = await moveToNamespaceService.AnalyzeTypeAtPositionAsync(
- document,
- testDocument.CursorPosition.Value,
- cancellationToken: cancellationToken).ConfigureAwait(false);
-
- return await moveToNamespaceService.MoveToNamespaceAsync(
- analysisResult,
- newNamespace,
- cancellationToken: cancellationToken).ConfigureAwait(false);
- }
- }
-}
diff --git a/src/EditorFeatures/TestUtilities/MoveToNamespace/TestMoveToNamespaceOptionsService.cs b/src/EditorFeatures/TestUtilities/MoveToNamespace/TestMoveToNamespaceOptionsService.cs
deleted file mode 100644
index 235eec8f7f97d945b9a2a89ab11139c4b3973ec1..0000000000000000000000000000000000000000
--- a/src/EditorFeatures/TestUtilities/MoveToNamespace/TestMoveToNamespaceOptionsService.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-extern alias WORKSPACES;
-
-using System;
-using System.Collections.Immutable;
-using System.ComponentModel.Composition;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.LanguageServices;
-using Microsoft.CodeAnalysis.MoveToNamespace;
-using Microsoft.CodeAnalysis.Notification;
-using WORKSPACES::Microsoft.CodeAnalysis.Host.Mef;
-
-namespace Microsoft.CodeAnalysis.Test.Utilities.MoveToNamespace
-{
- [Export(typeof(IMoveToNamespaceOptionsService))]
- [PartNotDiscoverable]
- class TestMoveToNamespaceOptionsService : IMoveToNamespaceOptionsService
- {
- [ImportingConstructor]
- [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
- public TestMoveToNamespaceOptionsService()
- {
- }
-
- public Task GetChangeNamespaceOptionsAsync(string defaultNamespace, ImmutableArray availableNamespaces, CancellationToken cancellationToken)
- {
- throw new NotImplementedException();
- }
- }
-}
diff --git a/src/EditorFeatures/TestUtilities/Roslyn.Services.Test.Utilities.csproj b/src/EditorFeatures/TestUtilities/Roslyn.Services.Test.Utilities.csproj
index 62770c6628f9f0d7feeb3539ee200797b22b2cf3..d15c29571a641fea1411dac98a4c730a3da2425d 100644
--- a/src/EditorFeatures/TestUtilities/Roslyn.Services.Test.Utilities.csproj
+++ b/src/EditorFeatures/TestUtilities/Roslyn.Services.Test.Utilities.csproj
@@ -110,4 +110,7 @@
+
+
+
\ No newline at end of file
diff --git a/src/Features/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Features.csproj b/src/Features/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Features.csproj
index c58a7b3a304f1517456fc1f6c2f916e6474adc8d..0c7746f6b199b84564fcd1f90f08e21b3630c276 100644
--- a/src/Features/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Features.csproj
+++ b/src/Features/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Features.csproj
@@ -69,5 +69,8 @@
+
+
+
\ No newline at end of file
diff --git a/src/Features/CSharp/Portable/MoveToNamespace/CSharpMoveToNamespaceService.cs b/src/Features/CSharp/Portable/MoveToNamespace/CSharpMoveToNamespaceService.cs
index 2457ca288f12be7265fdd76ac15ee26b8b8f726c..947477562666e8517299a71b4e79569486112a30 100644
--- a/src/Features/CSharp/Portable/MoveToNamespace/CSharpMoveToNamespaceService.cs
+++ b/src/Features/CSharp/Portable/MoveToNamespace/CSharpMoveToNamespaceService.cs
@@ -10,7 +10,7 @@ namespace Microsoft.CodeAnalysis.CSharp.MoveToNamespace
{
[ExportLanguageService(typeof(AbstractMoveToNamespaceService), LanguageNames.CSharp), Shared]
internal class CSharpMoveToNamespaceService :
- AbstractMoveToNamespaceService
+ AbstractMoveToNamespaceService
{
[ImportingConstructor]
[Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
@@ -21,8 +21,9 @@ internal class CSharpMoveToNamespaceService :
}
protected override string GetNamespaceName(NamespaceDeclarationSyntax syntax)
- {
- return syntax.Name.ToString();
- }
+ => syntax.Name.ToString();
+
+ protected override string GetNamespaceName(TypeDeclarationSyntax syntax)
+ => GetNamespaceName(syntax.FirstAncestorOrSelf());
}
}
diff --git a/src/Features/Core/Portable/MoveToNamespace/AbstractMoveToNamespaceService.cs b/src/Features/Core/Portable/MoveToNamespace/AbstractMoveToNamespaceService.cs
index 2d9108017ca046555ca000771ad3cc3eea328a6c..833226958900b47ee9aa2d31fadd8f39751ef367 100644
--- a/src/Features/Core/Portable/MoveToNamespace/AbstractMoveToNamespaceService.cs
+++ b/src/Features/Core/Portable/MoveToNamespace/AbstractMoveToNamespaceService.cs
@@ -23,12 +23,13 @@ internal abstract class AbstractMoveToNamespaceService : ILanguageService
public abstract Task GetOptionsAsync(Document document, string defaultNamespace, CancellationToken cancellationToken);
}
- internal abstract class AbstractMoveToNamespaceService
+ internal abstract class AbstractMoveToNamespaceService
: AbstractMoveToNamespaceService
{
private IMoveToNamespaceOptionsService _moveToNamespaceOptionsService;
protected abstract string GetNamespaceName(TNamespaceDeclarationSyntax syntax);
+ protected abstract string GetNamespaceName(TNamedTypeDeclarationSyntax syntax);
public AbstractMoveToNamespaceService(IMoveToNamespaceOptionsService moveToNamespaceOptionsService)
{
@@ -52,6 +53,7 @@ public AbstractMoveToNamespaceService(IMoveToNamespaceOptionsService moveToNames
int position,
CancellationToken cancellationToken)
{
+#if DEBUG // TODO: remove once the feature is done
var root = await document.GetSyntaxRootAsync().ConfigureAwait(false);
var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
@@ -60,71 +62,73 @@ public AbstractMoveToNamespaceService(IMoveToNamespaceOptionsService moveToNames
var symbolInfo = semanticModel.GetSymbolInfo(node, cancellationToken: cancellationToken);
var symbol = symbolInfo.Symbol;
+ var @namespace = symbol?.Name;
if (symbol is INamespaceSymbol namespaceSymbol)
{
node = node.FirstAncestorOrSelf(a => a is TNamespaceDeclarationSyntax);
+ @namespace = GetQualifiedName(namespaceSymbol);
}
if (node is TNamespaceDeclarationSyntax declarationSyntax)
{
if (ContainsNamespaceDeclaration(node))
{
- return new MoveToNamespaceAnalysisResult("Container contains nested namespace declaration");
+ return new MoveToNamespaceAnalysisResult("Namespace container contains nested namespace declaration");
}
- var @namespace = symbol?.Name ?? GetNamespaceName(declarationSyntax);
- return new MoveToNamespaceAnalysisResult(document, node, @namespace);
+ @namespace = @namespace ?? GetNamespaceName(declarationSyntax);
+ return new MoveToNamespaceAnalysisResult(document, node, @namespace, MoveToNamespaceAnalysisResult.ContainerType.Namespace);
+ }
+
+ if (symbol is INamedTypeSymbol namedTypeSymbol)
+ {
+ node = node.FirstAncestorOrSelf(a => a is TNamedTypeDeclarationSyntax);
+ @namespace = GetQualifiedName(namedTypeSymbol.ContainingNamespace);
+ }
+
+ if (node is TNamedTypeDeclarationSyntax namedTypeDeclarationSyntax)
+ {
+ @namespace = @namespace ?? GetNamespaceName(namedTypeDeclarationSyntax);
+ return new MoveToNamespaceAnalysisResult(document, node, @namespace, MoveToNamespaceAnalysisResult.ContainerType.NamedType);
}
return new MoveToNamespaceAnalysisResult("Not a valid position");
+#else
+ return new MoveToNamespaceAnalysisResult("Feature is not complete yet");
+#endif
}
private bool ContainsNamespaceDeclaration(SyntaxNode node)
=> node.DescendantNodes(n => n is TCompilationSyntax || n is TNamespaceDeclarationSyntax)
.OfType().Any();
- public override async Task MoveToNamespaceAsync(
+ public override Task MoveToNamespaceAsync(
MoveToNamespaceAnalysisResult analysisResult,
string targetNamespace,
CancellationToken cancellationToken)
{
- if (!analysisResult.CanPerform)
- {
- return MoveToNamespaceResult.Failed;
- }
-
- var changeNamespaceService = analysisResult.Document.GetLanguageService();
- if (changeNamespaceService == null)
- {
- return MoveToNamespaceResult.Failed;
- }
-
- var changedSolution = await changeNamespaceService.ChangeNamespaceAsync(
- analysisResult.Document,
- analysisResult.Container,
- targetNamespace,
- cancellationToken).ConfigureAwait(false);
-
- return new MoveToNamespaceResult(changedSolution, analysisResult.Document.Id);
+ // TODO: Implementation will be in a separate PR
+ return Task.FromResult(MoveToNamespaceResult.Failed);
}
private static SymbolDisplayFormat QualifiedNamespaceFormat = new SymbolDisplayFormat(
globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.Omitted,
typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces);
+ protected static string GetQualifiedName(INamespaceSymbol namespaceSymbol)
+ => namespaceSymbol.ToDisplayString(QualifiedNamespaceFormat);
+
public override async Task GetOptionsAsync(
Document document,
string defaultNamespace,
CancellationToken cancellationToken)
{
- var syntaxFactsService = document.GetLanguageService();
- var notificationService = document.Project.Solution.Workspace.Services.GetService();
var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
var namespaces = compilation.GlobalNamespace.GetAllNamespaces(cancellationToken)
.Where(n => n.NamespaceKind == NamespaceKind.Module && n.ContainingAssembly == compilation.Assembly)
- .Select(n => n.ToDisplayString(QualifiedNamespaceFormat));
+ .Select(GetQualifiedName);
return await _moveToNamespaceOptionsService.GetChangeNamespaceOptionsAsync(
defaultNamespace,
diff --git a/src/Features/Core/Portable/MoveToNamespace/MoveToNamespaceAnalysisResult.cs b/src/Features/Core/Portable/MoveToNamespace/MoveToNamespaceAnalysisResult.cs
index 548871f20acf76da655f4830e865f4c431f3392c..11b21b8004f7b791a0321dec2df3d5c05ef40b7b 100644
--- a/src/Features/Core/Portable/MoveToNamespace/MoveToNamespaceAnalysisResult.cs
+++ b/src/Features/Core/Portable/MoveToNamespace/MoveToNamespaceAnalysisResult.cs
@@ -14,16 +14,19 @@ internal class MoveToNamespaceAnalysisResult
public string ErrorMessage { get; }
public SyntaxNode Container { get; }
public string OriginalNamespace { get; }
+ public ContainerType Type { get; }
public MoveToNamespaceAnalysisResult(
Document document,
SyntaxNode container,
- string originalNamespace)
+ string originalNamespace,
+ ContainerType containerType)
{
CanPerform = true;
Document = document;
Container = container;
OriginalNamespace = originalNamespace;
+ Type = containerType;
}
public MoveToNamespaceAnalysisResult(string errorMessage)
@@ -31,5 +34,12 @@ public MoveToNamespaceAnalysisResult(string errorMessage)
CanPerform = false;
ErrorMessage = errorMessage;
}
+
+ public enum ContainerType
+ {
+ Namespace,
+ NamedType
+ }
+
}
}
diff --git a/src/VisualStudio/Core/Def/Implementation/MoveToNamespace/MoveToNamespaceDialog.xaml.cs b/src/VisualStudio/Core/Def/Implementation/MoveToNamespace/MoveToNamespaceDialog.xaml.cs
index b20809c299c1c428e674b1c142cd7084b821f1cf..bf0e44e571e6e70f22798389e16cc94b379e658f 100644
--- a/src/VisualStudio/Core/Def/Implementation/MoveToNamespace/MoveToNamespaceDialog.xaml.cs
+++ b/src/VisualStudio/Core/Def/Implementation/MoveToNamespace/MoveToNamespaceDialog.xaml.cs
@@ -14,7 +14,7 @@ internal partial class MoveToNamespaceDialog : DialogWindow
private readonly MoveToNamespaceDialogViewModel _viewModel;
public string MoveToNamespaceDialogTitle => ServicesVSResources.Move_to_namespace;
- public string NamespaceLabelText => "Target Namespace:"; // ServicesVSResources.Namespace_colon;
+ public string NamespaceLabelText => ServicesVSResources.Target_Namespace_colon;
public string OK => ServicesVSResources.OK;
public string Cancel => ServicesVSResources.Cancel;
diff --git a/src/VisualStudio/Core/Def/Implementation/MoveToNamespace/MoveToNamespaceDialogViewModel.cs b/src/VisualStudio/Core/Def/Implementation/MoveToNamespace/MoveToNamespaceDialogViewModel.cs
index ba254c6d3a598cf6c6f80fe1e985ea6737024afb..8122e452b986a9f6e815b2dbed19a1161d0b0561 100644
--- a/src/VisualStudio/Core/Def/Implementation/MoveToNamespace/MoveToNamespaceDialogViewModel.cs
+++ b/src/VisualStudio/Core/Def/Implementation/MoveToNamespace/MoveToNamespaceDialogViewModel.cs
@@ -24,7 +24,7 @@ class MoveToNamespaceDialogViewModel : AbstractNotifyPropertyChanged
private void MoveToNamespaceDialogViewModel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
- switch(e.PropertyName)
+ switch (e.PropertyName)
{
case nameof(NamespaceName):
OnNamespaceUpdated();
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
index 45d5c7d281842f14c6b3bfe4a936883d810e7633..b8300fe79b359d3c568619958df25891e7d79acd 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
@@ -1605,7 +1605,7 @@ internal class ServicesVSResources {
}
///
- /// Looks up a localized string similar to Move To Namespace.
+ /// Looks up a localized string similar to Move to Namespace.
///
internal static string Move_to_namespace {
get {
@@ -1641,11 +1641,11 @@ internal class ServicesVSResources {
}
///
- /// Looks up a localized string similar to Namespace:.
+ /// Looks up a localized string similar to Namespace.
///
- internal static string Namespace_colon {
+ internal static string Namespace {
get {
- return ResourceManager.GetString("Namespace:", resourceCulture);
+ return ResourceManager.GetString("Namespace", resourceCulture);
}
}
@@ -2826,6 +2826,15 @@ internal class ServicesVSResources {
}
}
+ ///
+ /// Looks up a localized string similar to Target Namespace:.
+ ///
+ internal static string Target_Namespace_colon {
+ get {
+ return ResourceManager.GetString("Target_Namespace_colon", resourceCulture);
+ }
+ }
+
///
/// Looks up a localized string similar to The analyzer assembly '{0}' has changed. Diagnostics may be incorrect until Visual Studio is restarted..
///
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index 2fea10ef7a104d21e8b536e1bc09943515fe9543..b618538e0199b6e7d711c85353f2e96858524607 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -1207,4 +1207,7 @@ I agree to all of the foregoing:
Namespace
+
+ Target Namespace:
+
\ No newline at end of file