From d0ece16ab138736963dc3582880501043825e53f Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 22 Nov 2024 10:37:49 -0800 Subject: [PATCH 1/4] Remove imports should only format the section of the document that was touched --- .../RemoveUnnecessaryImportsTests.cs | 36 +++++++++++- ...RemoveUnnecessaryImportsCodeFixProvider.cs | 8 +-- ...emoveUnnecessaryImportsService.Rewriter.cs | 4 +- .../CSharpRemoveUnnecessaryImportsService.cs | 57 ++++++------------- 4 files changed, 58 insertions(+), 47 deletions(-) diff --git a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryImports/RemoveUnnecessaryImportsTests.cs b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryImports/RemoveUnnecessaryImportsTests.cs index c538aa68e5bf9..de8563ded1116 100644 --- a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryImports/RemoveUnnecessaryImportsTests.cs +++ b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryImports/RemoveUnnecessaryImportsTests.cs @@ -19,8 +19,10 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.RemoveUnnecessaryImport CSharpRemoveUnnecessaryImportsCodeFixProvider>; [Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryImports)] -public class RemoveUnnecessaryImportsTests +public sealed class RemoveUnnecessaryImportsTests { + private static readonly string s_tab = "\t"; + [Fact] public async Task TestNoReferences() { @@ -2246,4 +2248,36 @@ static void Main(string[] args) """ }.RunAsync(); } + + [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/65114")] + public async Task DoNotTouchInnerNamespaceWithoutUsings() + { + await VerifyCS.VerifyCodeFixAsync( + $$""" + [|{|IDE0005:using System; + using System.Collections.Generic; + using System.Linq;|}|] + + namespace N + { + {{s_tab}}class Program + { + static void Main(string[] args) + { + } + } + } + """, + $$""" + namespace N + { + {{s_tab}}class Program + { + static void Main(string[] args) + { + } + } + } + """); + } } diff --git a/src/Analyzers/Core/CodeFixes/RemoveUnnecessaryImports/AbstractRemoveUnnecessaryImportsCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/RemoveUnnecessaryImports/AbstractRemoveUnnecessaryImportsCodeFixProvider.cs index a731d282a912c..c12b81448274a 100644 --- a/src/Analyzers/Core/CodeFixes/RemoveUnnecessaryImports/AbstractRemoveUnnecessaryImportsCodeFixProvider.cs +++ b/src/Analyzers/Core/CodeFixes/RemoveUnnecessaryImports/AbstractRemoveUnnecessaryImportsCodeFixProvider.cs @@ -2,13 +2,11 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. -using System; using System.Collections.Immutable; using System.Threading; using System.Threading.Tasks; using Microsoft.CodeAnalysis.CodeActions; using Microsoft.CodeAnalysis.CodeFixes; -using Microsoft.CodeAnalysis.Diagnostics; using Microsoft.CodeAnalysis.Formatting; using Microsoft.CodeAnalysis.Shared.Extensions; @@ -30,7 +28,7 @@ public sealed override Task RegisterCodeFixesAsync(CodeFixContext context) context.RegisterCodeFix( CodeAction.Create( title, - c => RemoveUnnecessaryImportsAsync(context.Document, c), + cancellationToken => RemoveUnnecessaryImportsAsync(context.Document, cancellationToken), title), context.Diagnostics); return Task.CompletedTask; @@ -38,11 +36,11 @@ public sealed override Task RegisterCodeFixesAsync(CodeFixContext context) protected abstract string GetTitle(); - private static async Task RemoveUnnecessaryImportsAsync( + private static Task RemoveUnnecessaryImportsAsync( Document document, CancellationToken cancellationToken) { var service = document.GetRequiredLanguageService(); - return await service.RemoveUnnecessaryImportsAsync(document, cancellationToken).ConfigureAwait(false); + return service.RemoveUnnecessaryImportsAsync(document, cancellationToken); } } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.Rewriter.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.Rewriter.cs index 4db25ff8b4363..332951421c61a 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.Rewriter.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.Rewriter.cs @@ -189,7 +189,7 @@ public override SyntaxNode VisitCompilationUnit(CompilationUnitSyntax node) resultCompilationUnit = resultCompilationUnit.ReplaceToken(firstToken, newFirstToken); } - return resultCompilationUnit; + return resultCompilationUnit.WithAdditionalAnnotations(s_annotation); } public override SyntaxNode VisitFileScopedNamespaceDeclaration(FileScopedNamespaceDeclarationSyntax node) @@ -241,7 +241,7 @@ private SyntaxNode VisitBaseNamespaceDeclaration( resultNamespace = resultNamespace.ReplaceToken(firstToken, newFirstToken); } - return resultNamespace; + return resultNamespace.WithAdditionalAnnotations(s_annotation); } public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node) diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.cs index f014b6b6ce952..0d4435cf001cb 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.cs @@ -3,17 +3,16 @@ // See the LICENSE file in the project root for more information. using System; -using System.Collections.Generic; using System.Composition; using System.Linq; using System.Threading; using System.Threading.Tasks; -using Microsoft.CodeAnalysis.CodeActions; using Microsoft.CodeAnalysis.CSharp.Formatting; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Formatting; using Microsoft.CodeAnalysis.Host.Mef; using Microsoft.CodeAnalysis.Internal.Log; +using Microsoft.CodeAnalysis.PooledObjects; using Microsoft.CodeAnalysis.RemoveUnnecessaryImports; using Microsoft.CodeAnalysis.Shared.Extensions; using Microsoft.CodeAnalysis.Text; @@ -22,14 +21,12 @@ namespace Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryImports; [ExportLanguageService(typeof(IRemoveUnnecessaryImportsService), LanguageNames.CSharp), Shared] -internal partial class CSharpRemoveUnnecessaryImportsService : +[method: ImportingConstructor] +[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] +internal partial class CSharpRemoveUnnecessaryImportsService() : AbstractRemoveUnnecessaryImportsService { - [ImportingConstructor] - [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] - public CSharpRemoveUnnecessaryImportsService() - { - } + private static readonly SyntaxAnnotation s_annotation = new(); private static ISyntaxFormatting SyntaxFormatting => CSharpSyntaxFormatting.Instance; @@ -54,13 +51,22 @@ public override async Task RemoveUnnecessaryImportsAsync( var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); - var oldRoot = (CompilationUnitSyntax)root; - var newRoot = (CompilationUnitSyntax)new Rewriter(unnecessaryImports, cancellationToken).Visit(oldRoot); + var newRoot = new Rewriter(unnecessaryImports, cancellationToken).Visit(root); cancellationToken.ThrowIfCancellationRequested(); - var spansToFormat = new List(); - AddFormattingSpans(newRoot, spansToFormat, cancellationToken); + using var _ = ArrayBuilder.GetInstance(out var spansToFormat); + foreach (var node in newRoot.GetAnnotatedNodes(s_annotation)) + { + if (node is CompilationUnitSyntax { Members: [var firstMemberA, ..] }) + { + spansToFormat.Add(TextSpan.FromBounds(0, firstMemberA.SpanStart)); + } + else if (node is BaseNamespaceDeclarationSyntax { Members: [var firstMemberB, ..] } baseNamespace) + { + spansToFormat.Add(TextSpan.FromBounds(baseNamespace.Name.Span.End, firstMemberB.SpanStart)); + } + } var formattingOptions = await document.GetSyntaxFormattingOptionsAsync(SyntaxFormatting, cancellationToken).ConfigureAwait(false); var formattedRoot = SyntaxFormatting.GetFormattingResult(newRoot, spansToFormat, formattingOptions, rules: default, cancellationToken).GetFormattedRoot(cancellationToken); @@ -68,31 +74,4 @@ public override async Task RemoveUnnecessaryImportsAsync( return document.WithSyntaxRoot(formattedRoot); } } - - private static void AddFormattingSpans( - CompilationUnitSyntax compilationUnit, - List spans, - CancellationToken cancellationToken) - { - cancellationToken.ThrowIfCancellationRequested(); - spans.Add(TextSpan.FromBounds(0, GetEndPosition(compilationUnit, compilationUnit.Members))); - - foreach (var @namespace in compilationUnit.Members.OfType()) - AddFormattingSpans(@namespace, spans, cancellationToken); - } - - private static void AddFormattingSpans( - BaseNamespaceDeclarationSyntax namespaceMember, - List spans, - CancellationToken cancellationToken) - { - cancellationToken.ThrowIfCancellationRequested(); - spans.Add(TextSpan.FromBounds(namespaceMember.SpanStart, GetEndPosition(namespaceMember, namespaceMember.Members))); - - foreach (var @namespace in namespaceMember.Members.OfType()) - AddFormattingSpans(@namespace, spans, cancellationToken); - } - - private static int GetEndPosition(SyntaxNode container, SyntaxList list) - => list.Count > 0 ? list[0].SpanStart : container.Span.End; } From ee2bc02c24a1574f8470017af0eefe1bb81b28cb Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 22 Nov 2024 16:52:38 -0800 Subject: [PATCH 2/4] use raw strings in tests --- SpellingExclusions.dic | 1 + .../SyncNamespaceTests_ChangeNamespace.cs | 3517 +++++++++-------- 2 files changed, 1806 insertions(+), 1712 deletions(-) diff --git a/SpellingExclusions.dic b/SpellingExclusions.dic index 44098153565f7..17a33d838ea5c 100644 --- a/SpellingExclusions.dic +++ b/SpellingExclusions.dic @@ -2,3 +2,4 @@ awaitable Refactorings Infos +cref diff --git a/src/EditorFeatures/CSharpTest/CodeActions/SyncNamespace/SyncNamespaceTests_ChangeNamespace.cs b/src/EditorFeatures/CSharpTest/CodeActions/SyncNamespace/SyncNamespaceTests_ChangeNamespace.cs index 51b73da12df25..d74102910a0dd 100644 --- a/src/EditorFeatures/CSharpTest/CodeActions/SyncNamespace/SyncNamespaceTests_ChangeNamespace.cs +++ b/src/EditorFeatures/CSharpTest/CodeActions/SyncNamespace/SyncNamespaceTests_ChangeNamespace.cs @@ -2,8 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. -#nullable disable - using System.Threading.Tasks; using Microsoft.CodeAnalysis.Test.Utilities; using Roslyn.Test.Utilities; @@ -23,19 +21,20 @@ public async Task ChangeNamespace_InvalidFolderName1() // No change namespace action because the folder name is not valid identifier var (folder, filePath) = CreateDocumentFilePath(["3B", "C"], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - }} -}} - - -"; + $$""" + + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + } + } + + + + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal: null); } @@ -48,19 +47,20 @@ public async Task ChangeNamespace_InvalidFolderName2() // No change namespace action because the folder name is not valid identifier var (folder, filePath) = CreateDocumentFilePath(["B.3C", "D"], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - }} -}} - - -"; + $$""" + + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + } + } + + + + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal: null); } @@ -72,26 +72,29 @@ public async Task ChangeNamespace_SingleDocumentNoReference() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - }} -}} - -"; + $$""" + + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - class Class1 - { - } -}"; + """ + namespace A.B.C + { + class Class1 + { + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal); } @@ -103,26 +106,26 @@ public async Task ChangeNamespace_SingleDocumentNoReference_FileScopedNamespace( var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace}; - -class Class1 -{{ -}} - - -"; + $$""" + + + namespace [||]{{declaredNamespace}}; + + class Class1 + { + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C; + """ + namespace A.B.C; -class Class1 -{ -} -"; + class Class1 + { + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal); } @@ -134,46 +137,49 @@ public async Task ChangeNamespace_SingleDocumentLocalReference() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - delegate void D1; - - interface Class1 - {{ - void M1(); - }} - - class Class2 : {declaredNamespace}.Class1 - {{ - {declaredNamespace}.D1 d; - - void {declaredNamespace}.Class1.M1(){{}} - }} -}} - -"; + $$""" + + + + namespace [||]{{declaredNamespace}} + { + delegate void D1; + + interface Class1 + { + void M1(); + } + + class Class2 : {{declaredNamespace}}.Class1 + { + {{declaredNamespace}}.D1 d; + + void {{declaredNamespace}}.Class1.M1(){} + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - delegate void D1; - - interface Class1 - { - void M1(); - } - - class Class2 : Class1 - { - D1 d; - - void Class1.M1() { } - } -}"; + """ + namespace A.B.C + { + delegate void D1; + + interface Class1 + { + void M1(); + } + + class Class2 : Class1 + { + D1 d; + + void Class1.M1() { } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal); } @@ -186,71 +192,73 @@ public async Task ChangeNamespace_WithCrefReference() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - /// <summary> - /// See <see cref=""Class1""/> - /// See <see cref=""{declaredNamespace}.Class1""/> - /// See <see cref=""global::{declaredNamespace}.Class1""/> - /// See <see cref=""global::{declaredNamespace}.Class1.M1""/> - /// </summary> - public class Class1 - {{ - public void M1() {{ }} - }} -}} - -namespace Foo -{{ - using {declaredNamespace}; - - /// <summary> - /// See <see cref=""Class1""/> - /// See <see cref=""{declaredNamespace}.Class1""/> - /// See <see cref=""global::{declaredNamespace}.Class1""/> - /// See <see cref=""global::{declaredNamespace}.Class1.M1""/> - /// </summary> - class RefClass - {{ - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + /// <summary> + /// See <see cref="Class1"/> + /// See <see cref="{{declaredNamespace}}.Class1"/> + /// See <see cref="global::{{declaredNamespace}}.Class1"/> + /// See <see cref="global::{{declaredNamespace}}.Class1.M1"/> + /// </summary> + public class Class1 + { + public void M1() { } + } + } + namespace Foo + { + using {{declaredNamespace}}; + + /// <summary> + /// See <see cref="Class1"/> + /// See <see cref="{{declaredNamespace}}.Class1"/> + /// See <see cref="global::{{declaredNamespace}}.Class1"/> + /// See <see cref="global::{{declaredNamespace}}.Class1.M1"/> + /// </summary> + class RefClass + { + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - /// - /// See - /// See - /// See - /// See - /// - public class Class1 - { - public void M1() { } - } -}"; + """ + namespace A.B.C + { + /// + /// See + /// See + /// See + /// See + /// + public class Class1 + { + public void M1() { } + } + } + """; var expectedSourceReference = -@" -namespace Foo -{ - using A.B.C; - - /// - /// See - /// See - /// See - /// See - /// - class RefClass - { - } -}"; + """ + namespace Foo + { + using A.B.C; + + /// + /// See + /// See + /// See + /// See + /// + class RefClass + { + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -262,57 +270,59 @@ public async Task ChangeNamespace_WithCrefReferencesInVB() var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - /// <summary> - /// See <see cref=""Class1""/> - /// See <see cref=""{declaredNamespace}.Class1""/> - /// </summary> - public class Class1 - {{ - }} -}} - - - -Imports {declaredNamespace} - -''' <summary> -''' See <see cref=""Class1""/> -''' See <see cref=""{declaredNamespace}.Class1""/> -''' </summary> -Public Class VBClass - Public ReadOnly Property C1 As Class1 -End Class - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + /// <summary> + /// See <see cref="Class1"/> + /// See <see cref="{{declaredNamespace}}.Class1"/> + /// </summary> + public class Class1 + { + } + } + + + Imports {{declaredNamespace}} + + ''' <summary> + ''' See <see cref="Class1"/> + ''' See <see cref="{{declaredNamespace}}.Class1"/> + ''' </summary> + Public Class VBClass + Public ReadOnly Property C1 As Class1 + End Class + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - /// - /// See - /// See - /// - public class Class1 - { - } -}"; + """ + namespace A.B.C + { + /// + /// See + /// See + /// + public class Class1 + { + } + } + """; var expectedSourceReference = -@" -Imports A.B.C - -''' -''' See -''' See -''' -Public Class VBClass - Public ReadOnly Property C1 As Class1 -End Class"; + """ + Imports A.B.C + + ''' + ''' See + ''' See + ''' + Public Class VBClass + Public ReadOnly Property C1 As Class1 + End Class + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -325,51 +335,54 @@ public async Task ChangeNamespace_ReferencingTypesDeclaredInOtherDocument() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - private Class2 c2; - private Class3 c3; - private Class4 c4; - }} -}} - -namespace Foo -{{ - class Class2 {{}} - - namespace Bar - {{ - class Class3 {{}} - - namespace Baz - {{ - class Class4 {{}} - }} - }} -}} - -"; + $$""" + + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + private Class2 c2; + private Class3 c3; + private Class4 c4; + } + } + + namespace Foo + { + class Class2 {} + + namespace Bar + { + class Class3 {} + + namespace Baz + { + class Class4 {} + } + } + } + + + """; var expectedSourceOriginal = -@"using Foo; -using Foo.Bar; -using Foo.Bar.Baz; - -namespace A.B.C -{ - class Class1 - { - private Class2 c2; - private Class3 c3; - private Class4 c4; - } -}"; + """ + using Foo; + using Foo.Bar; + using Foo.Bar.Baz; + + namespace A.B.C + { + class Class1 + { + private Class2 c2; + private Class3 c3; + private Class4 c4; + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal); } @@ -382,51 +395,54 @@ public async Task ChangeNamespace_ReferencingQualifiedTypesDeclaredInOtherDocume var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - private Foo.Class2 c2; - private Foo.Bar.Class3 c3; - private Foo.Bar.Baz.Class4 c4; - }} -}} - -namespace Foo -{{ - class Class2 {{}} - - namespace Bar - {{ - class Class3 {{}} - - namespace Baz - {{ - class Class4 {{}} - }} - }} -}} - -"; + $$""" + + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + private Foo.Class2 c2; + private Foo.Bar.Class3 c3; + private Foo.Bar.Baz.Class4 c4; + } + } + + namespace Foo + { + class Class2 {} + + namespace Bar + { + class Class3 {} + + namespace Baz + { + class Class4 {} + } + } + } + + + """; var expectedSourceOriginal = -@"using Foo; -using Foo.Bar; -using Foo.Bar.Baz; - -namespace A.B.C -{ - class Class1 - { - private Class2 c2; - private Class3 c3; - private Class4 c4; - } -}"; + """ + using Foo; + using Foo.Bar; + using Foo.Bar.Baz; + + namespace A.B.C + { + class Class1 + { + private Class2 c2; + private Class3 c3; + private Class4 c4; + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal); } @@ -439,65 +455,67 @@ public async Task ChangeNamespace_WithReferencesInOtherDocument() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - }} - - class Class2 - {{ - }} -}} - -using Foo.Bar.Baz; - -namespace Foo -{{ - class RefClass - {{ - private Class1 c1; - - void M1() - {{ - Bar.Baz.Class2 c2 = null; - }} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + } + + class Class2 + { + } + } + using Foo.Bar.Baz; + + namespace Foo + { + class RefClass + { + private Class1 c1; + + void M1() + { + Bar.Baz.Class2 c2 = null; + } + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - class Class1 - { - } - - class Class2 - { - } -}"; + """ + namespace A.B.C + { + class Class1 + { + } + + class Class2 + { + } + } + """; var expectedSourceReference = -@" -using A.B.C; - -namespace Foo -{ - class RefClass - { - private Class1 c1; - - void M1() - { - Class2 c2 = null; - } - } -}"; + """ + using A.B.C; + + namespace Foo + { + class RefClass + { + private Class1 c1; + + void M1() + { + Class2 c2 = null; + } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -510,49 +528,51 @@ public async Task ChangeNamespace_WithQualifiedReferencesInOtherDocument() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - interface Interface1 - {{ - void M1(Interface1 c1); - }} -}} - -namespace Foo -{{ - using {declaredNamespace}; - - class RefClass : Interface1 - {{ - void {declaredNamespace}.Interface1.M1(Interface1 c1){{}} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + interface Interface1 + { + void M1(Interface1 c1); + } + } + namespace Foo + { + using {{declaredNamespace}}; + + class RefClass : Interface1 + { + void {{declaredNamespace}}.Interface1.M1(Interface1 c1){} + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - interface Interface1 - { - void M1(Interface1 c1); - } -}"; + """ + namespace A.B.C + { + interface Interface1 + { + void M1(Interface1 c1); + } + } + """; var expectedSourceReference = -@" -namespace Foo -{ - using A.B.C; - - class RefClass : Interface1 - { - void Interface1.M1(Interface1 c1){} - } -}"; + """ + namespace Foo + { + using A.B.C; + + class RefClass : Interface1 + { + void Interface1.M1(Interface1 c1){} + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -565,65 +585,67 @@ public async Task ChangeNamespace_ChangeUsingsInMultipleContainers() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - }} -}} - -namespace NS1 -{{ - using Foo.Bar.Baz; - - class Class2 - {{ - Class1 c2; - }} - - namespace NS2 - {{ - using Foo.Bar.Baz; - - class Class2 - {{ - Class1 c1; - }} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + } + } + namespace NS1 + { + using Foo.Bar.Baz; + + class Class2 + { + Class1 c2; + } + + namespace NS2 + { + using Foo.Bar.Baz; + + class Class2 + { + Class1 c1; + } + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - class Class1 - { - } -}"; + """ + namespace A.B.C + { + class Class1 + { + } + } + """; var expectedSourceReference = -@" -namespace NS1 -{ - using A.B.C; - - class Class2 - { - Class1 c2; - } - - namespace NS2 - { - class Class2 - { - Class1 c1; - } - } -}"; + """ + namespace NS1 + { + using A.B.C; + + class Class2 + { + Class1 c2; + } + + namespace NS2 + { + class Class2 + { + Class1 c1; + } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -636,68 +658,70 @@ public async Task ChangeNamespace_WithAliasReferencesInOtherDocument() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - }} - - class Class2 - {{ - }} -}} - -using System; -using Class1Alias = Foo.Bar.Baz.Class1; - -namespace Foo -{{ - class RefClass - {{ - private Class1Alias c1; - - void M1() - {{ - Bar.Baz.Class2 c2 = null; - }} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + } + + class Class2 + { + } + } + using System; + using Class1Alias = Foo.Bar.Baz.Class1; + + namespace Foo + { + class RefClass + { + private Class1Alias c1; + + void M1() + { + Bar.Baz.Class2 c2 = null; + } + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - class Class1 - { - } - - class Class2 - { - } -}"; + """ + namespace A.B.C + { + class Class1 + { + } + + class Class2 + { + } + } + """; var expectedSourceReference = -@" -using System; -using A.B.C; -using Class1Alias = A.B.C.Class1; - -namespace Foo -{ - class RefClass - { - private Class1Alias c1; - - void M1() - { - Class2 c2 = null; - } - } -}"; + """ + using System; + using A.B.C; + using Class1Alias = A.B.C.Class1; + + namespace Foo + { + class RefClass + { + private Class1Alias c1; + + void M1() + { + Class2 c2 = null; + } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -709,36 +733,37 @@ public async Task ChangeToGlobalNamespace_SingleDocumentNoRef() var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var code = -$@" - - - -using System; - -// Comments before declaration. -namespace [||]{declaredNamespace} -{{ // Comments after opening brace - class Class1 - {{ - }} - // Comments before closing brace -}} // Comments after declaration. - - -"; + $$""" + + + using System; + + // Comments before declaration. + namespace [||]{{declaredNamespace}} + { // Comments after opening brace + class Class1 + { + } + // Comments before closing brace + } // Comments after declaration. + + + + """; var expectedSourceOriginal = -@" -using System; - -// Comments before declaration. -// Comments after opening brace -class Class1 -{ -} -// Comments before closing brace -// Comments after declaration. -"; + """ + using System; + + // Comments before declaration. + // Comments after opening brace + class Class1 + { + } + // Comments before closing brace + // Comments after declaration. + + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal); } @@ -750,44 +775,46 @@ public async Task ChangeToGlobalNamespace_SingleDocumentLocalRef() var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - delegate void D1; - - interface Class1 - {{ - void M1(); - }} - - class Class2 : {declaredNamespace}.Class1 - {{ - global::{declaredNamespace}.D1 d; - - void {declaredNamespace}.Class1.M1() {{ }} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + delegate void D1; + + interface Class1 + { + void M1(); + } + + class Class2 : {{declaredNamespace}}.Class1 + { + global::{{declaredNamespace}}.D1 d; + + void {{declaredNamespace}}.Class1.M1() { } + } + } + + + """; var expectedSourceOriginal = -@"delegate void D1; + """ + delegate void D1; -interface Class1 -{ - void M1(); -} + interface Class1 + { + void M1(); + } -class Class2 : Class1 -{ - global::D1 d; + class Class2 : Class1 + { + global::D1 d; - void Class1.M1() { } -} -"; + void Class1.M1() { } + } + + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal); } @@ -800,60 +827,63 @@ public async Task ChangeToGlobalNamespace_WithReferencesInOtherDocument() var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - }} - - class Class2 - {{ - }} -}} - -using Foo.Bar.Baz; - -namespace Foo -{{ - class RefClass - {{ - private Class1 c1; - - void M1() - {{ - Bar.Baz.Class2 c2 = null; - }} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + } + + class Class2 + { + } + } + using Foo.Bar.Baz; + + namespace Foo + { + class RefClass + { + private Class1 c1; + + void M1() + { + Bar.Baz.Class2 c2 = null; + } + } + } + + + """; var expectedSourceOriginal = -@"class Class1 -{ -} + """ + class Class1 + { + } -class Class2 -{ -} -"; - var expectedSourceReference = -@"namespace Foo -{ - class RefClass - { - private Class1 c1; + class Class2 + { + } - void M1() - { - Class2 c2 = null; - } - } -}"; + """; + var expectedSourceReference = + """ + namespace Foo + { + class RefClass + { + private Class1 c1; + + void M1() + { + Class2 c2 = null; + } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -866,45 +896,47 @@ public async Task ChangeToGlobalNamespace_WithQualifiedReferencesInOtherDocument var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - interface Interface1 - {{ - void M1(Interface1 c1); - }} -}} - -namespace Foo -{{ - using {declaredNamespace}; - - class RefClass : Interface1 - {{ - void {declaredNamespace}.Interface1.M1(Interface1 c1){{}} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + interface Interface1 + { + void M1(Interface1 c1); + } + } + namespace Foo + { + using {{declaredNamespace}}; + + class RefClass : Interface1 + { + void {{declaredNamespace}}.Interface1.M1(Interface1 c1){} + } + } + + + """; var expectedSourceOriginal = -@"interface Interface1 -{ - void M1(Interface1 c1); -} -"; + """ + interface Interface1 + { + void M1(Interface1 c1); + } + + """; var expectedSourceReference = -@" -namespace Foo -{ - class RefClass : Interface1 - { - void Interface1.M1(Interface1 c1){} - } -}"; + """ + namespace Foo + { + class RefClass : Interface1 + { + void Interface1.M1(Interface1 c1){} + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -917,51 +949,53 @@ public async Task ChangeToGlobalNamespace_WithReferenceAndConflictDeclarationInO var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class MyClass - {{ - }} -}} - -namespace Foo -{{ - using {declaredNamespace}; - - class RefClass - {{ - Foo.Bar.Baz.MyClass c; - }} - - class MyClass - {{ - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + class MyClass + { + } + } + namespace Foo + { + using {{declaredNamespace}}; + + class RefClass + { + Foo.Bar.Baz.MyClass c; + } + + class MyClass + { + } + } + + + """; var expectedSourceOriginal = -@"class MyClass -{ -} -"; - var expectedSourceReference = -@" -namespace Foo -{ - class RefClass - { - global::MyClass c; - } + """ + class MyClass + { + } - class MyClass - { - } -}"; + """; + var expectedSourceReference = + """ + namespace Foo + { + class RefClass + { + global::MyClass c; + } + + class MyClass + { + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -974,49 +1008,50 @@ public async Task ChangeToGlobalNamespace_ReferencingTypesDeclaredInOtherDocumen var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - private Class2 c2; - private Class3 c3; - private Class4 c4; - }} -}} - -namespace Foo -{{ - class Class2 {{}} - - namespace Bar - {{ - class Class3 {{}} - - namespace Baz - {{ - class Class4 {{}} - }} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + private Class2 c2; + private Class3 c3; + private Class4 c4; + } + } + namespace Foo + { + class Class2 {} + + namespace Bar + { + class Class3 {} + + namespace Baz + { + class Class4 {} + } + } + } + + + """; var expectedSourceOriginal = -@"using Foo; -using Foo.Bar; -using Foo.Bar.Baz; - -class Class1 -{ - private Class2 c2; - private Class3 c3; - private Class4 c4; -} -"; + """ + using Foo; + using Foo.Bar; + using Foo.Bar.Baz; + + class Class1 + { + private Class2 c2; + private Class3 c3; + private Class4 c4; + } + + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal); } @@ -1029,61 +1064,63 @@ public async Task ChangeToGlobalNamespace_ChangeUsingsInMultipleContainers() var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - }} -}} - -namespace NS1 -{{ - using Foo.Bar.Baz; - - class Class2 - {{ - Class1 c2; - }} - - namespace NS2 - {{ - using Foo.Bar.Baz; - - class Class2 - {{ - Class1 c1; - }} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + } + } + namespace NS1 + { + using Foo.Bar.Baz; + + class Class2 + { + Class1 c2; + } + + namespace NS2 + { + using Foo.Bar.Baz; + + class Class2 + { + Class1 c1; + } + } + } + + + """; var expectedSourceOriginal = -@"class Class1 -{ -} -"; - var expectedSourceReference = -@" -namespace NS1 -{ - class Class2 - { - Class1 c2; - } + """ + class Class1 + { + } - namespace NS2 - { - class Class2 - { - Class1 c1; - } - } -}"; + """; + var expectedSourceReference = + """ + namespace NS1 + { + class Class2 + { + Class1 c2; + } + + namespace NS2 + { + class Class2 + { + Class1 c1; + } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1096,65 +1133,67 @@ public async Task ChangeToGlobalNamespace_WithAliasReferencesInOtherDocument() var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - class Class1 - {{ - }} - - class Class2 - {{ - }} -}} - -using System; -using Class1Alias = Foo.Bar.Baz.Class1; - -namespace Foo -{{ - class RefClass - {{ - private Class1Alias c1; - - void M1() - {{ - Bar.Baz.Class2 c2 = null; - }} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + class Class1 + { + } + + class Class2 + { + } + } + using System; + using Class1Alias = Foo.Bar.Baz.Class1; + + namespace Foo + { + class RefClass + { + private Class1Alias c1; + + void M1() + { + Bar.Baz.Class2 c2 = null; + } + } + } + + + """; var expectedSourceOriginal = -@"class Class1 -{ -} - -class Class2 -{ -} -"; - var expectedSourceReference = -@" -using System; -using Class1Alias = Class1; + """ + class Class1 + { + } -namespace Foo -{ - class RefClass - { - private Class1Alias c1; + class Class2 + { + } - void M1() - { - Class2 c2 = null; - } - } -}"; + """; + var expectedSourceReference = + """ + using System; + using Class1Alias = Class1; + + namespace Foo + { + class RefClass + { + private Class1Alias c1; + + void M1() + { + Class2 c2 = null; + } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1164,29 +1203,30 @@ public async Task ChangeFromGlobalNamespace_SingleDocumentNoRef() var defaultNamespace = "A"; var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var code = -$@" - - - -using System; - -class [||]Class1 -{{ -}} - - -"; + $$""" + + + using System; + + class [||]Class1 + { + } + + + + """; var expectedSourceOriginal = -@" -using System; - -namespace A.B.C -{ - class Class1 - { - } -}"; + """ + using System; + + namespace A.B.C + { + class Class1 + { + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal); } @@ -1196,43 +1236,46 @@ public async Task ChangeFromGlobalNamespace_SingleDocumentLocalRef() var defaultNamespace = "A"; var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var code = -$@" - - - -delegate void [||]D1; - -interface Class1 -{{ - void M1(); -}} - -class Class2 : Class1 -{{ - D1 d; - - void Class1.M1() {{ }} -}} - -"; + $$""" + + + + delegate void [||]D1; + + interface Class1 + { + void M1(); + } + + class Class2 : Class1 + { + D1 d; + + void Class1.M1() { } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - delegate void D1; - - interface Class1 - { - void M1(); - } - - class Class2 : Class1 - { - D1 d; - - void Class1.M1() { } - } -}"; + """ + namespace A.B.C + { + delegate void D1; + + interface Class1 + { + void M1(); + } + + class Class2 : Class1 + { + D1 d; + + void Class1.M1() { } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal); } @@ -1244,60 +1287,62 @@ public async Task ChangeFromGlobalNamespace_WithReferencesInOtherDocument() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -class [||]Class1 -{{ -}} - -class Class2 -{{ -}} - -namespace Foo -{{ - class RefClass - {{ - private Class1 c1; - - void M1() - {{ - Class2 c2 = null; - }} - }} -}} - -"; + $$""" + + + class [||]Class1 + { + } + + class Class2 + { + } + namespace Foo + { + class RefClass + { + private Class1 c1; + + void M1() + { + Class2 c2 = null; + } + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - class Class1 - { - } - - class Class2 - { - } -}"; + """ + namespace A.B.C + { + class Class1 + { + } + + class Class2 + { + } + } + """; var expectedSourceReference = -@" -using A.B.C; - -namespace Foo -{ - class RefClass - { - private Class1 c1; - - void M1() - { - Class2 c2 = null; - } - } -}"; + """ + using A.B.C; + + namespace Foo + { + class RefClass + { + private Class1 c1; + + void M1() + { + Class2 c2 = null; + } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1308,44 +1353,46 @@ public async Task ChangeFromGlobalNamespace_WithQualifiedReferencesInOtherDocume var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -interface [||]Interface1 -{{ - void M1(Interface1 c1); -}} - -namespace Foo -{{ - class RefClass : Interface1 - {{ - void Interface1.M1(Interface1 c1){{}} - }} -}} - -"; + $$""" + + + interface [||]Interface1 + { + void M1(Interface1 c1); + } + namespace Foo + { + class RefClass : Interface1 + { + void Interface1.M1(Interface1 c1){} + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - interface Interface1 - { - void M1(Interface1 c1); - } -}"; + """ + namespace A.B.C + { + interface Interface1 + { + void M1(Interface1 c1); + } + } + """; var expectedSourceReference = -@" -using A.B.C; - -namespace Foo -{ - class RefClass : Interface1 - { - void Interface1.M1(Interface1 c1){} - } -}"; + """ + using A.B.C; + + namespace Foo + { + class RefClass : Interface1 + { + void Interface1.M1(Interface1 c1){} + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1356,45 +1403,48 @@ public async Task ChangeFromGlobalNamespace_ReferencingQualifiedTypesDeclaredInO var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -class [||]Class1 -{{ - private A.Class2 c2; - private A.B.Class3 c3; - private A.B.C.Class4 c4; -}} - - -namespace A -{{ - class Class2 {{}} - - namespace B - {{ - class Class3 {{}} - - namespace C - {{ - class Class4 {{}} - }} - }} -}} - -"; + $$""" + + + + class [||]Class1 + { + private A.Class2 c2; + private A.B.Class3 c3; + private A.B.C.Class4 c4; + } + + + namespace A + { + class Class2 {} + + namespace B + { + class Class3 {} + + namespace C + { + class Class4 {} + } + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - class Class1 - { - private Class2 c2; - private Class3 c3; - private Class4 c4; - } -}"; + """ + namespace A.B.C + { + class Class1 + { + private Class2 c2; + private Class3 c3; + private Class4 c4; + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal); } @@ -1406,65 +1456,67 @@ public async Task ChangeFromGlobalNamespace_ChangeUsingsInMultipleContainers() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -class [||]Class1 -{{ -}} - -namespace NS1 -{{ - using System; - - class Class2 - {{ - Class1 c2; - }} - - namespace NS2 - {{ - using System; - - class Class2 - {{ - Class1 c1; - }} - }} -}} - -"; + $$""" + + + class [||]Class1 + { + } + namespace NS1 + { + using System; + + class Class2 + { + Class1 c2; + } + + namespace NS2 + { + using System; + + class Class2 + { + Class1 c1; + } + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - class Class1 - { - } -}"; + """ + namespace A.B.C + { + class Class1 + { + } + } + """; var expectedSourceReference = -@" -namespace NS1 -{ - using System; - using A.B.C; - - class Class2 - { - Class1 c2; - } - - namespace NS2 - { - using System; - - class Class2 - { - Class1 c1; - } - } -}"; + """ + namespace NS1 + { + using System; + using A.B.C; + + class Class2 + { + Class1 c2; + } + + namespace NS2 + { + using System; + + class Class2 + { + Class1 c1; + } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1476,67 +1528,69 @@ public async Task ChangeFromGlobalNamespace_WithAliasReferencesInOtherDocument() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -class [||]Class1 -{{ -}} - -class Class2 -{{ -}} - -using Class1Alias = Class1; - -namespace Foo -{{ - using System; - - class RefClass - {{ - private Class1Alias c1; - - void M1() - {{ - Class2 c2 = null; - }} - }} -}} - -"; + $$""" + + + class [||]Class1 + { + } + + class Class2 + { + } + using Class1Alias = Class1; + + namespace Foo + { + using System; + + class RefClass + { + private Class1Alias c1; + + void M1() + { + Class2 c2 = null; + } + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - class Class1 - { - } - - class Class2 - { - } -}"; + """ + namespace A.B.C + { + class Class1 + { + } + + class Class2 + { + } + } + """; var expectedSourceReference = -@" -using A.B.C; -using Class1Alias = Class1; - -namespace Foo -{ - using System; - - class RefClass - { - private Class1Alias c1; - - void M1() - { - Class2 c2 = null; - } - } -}"; + """ + using A.B.C; + using Class1Alias = Class1; + + namespace Foo + { + using System; + + class RefClass + { + private Class1Alias c1; + + void M1() + { + Class2 c2 = null; + } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1548,41 +1602,43 @@ public async Task ChangeNamespace_WithReferencesInVBDocument() var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - public class Class1 - {{ - }} -}} - - - -Imports {declaredNamespace} - -Public Class VBClass - Public ReadOnly Property C1 As Class1 -End Class - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + public class Class1 + { + } + } + + + Imports {{declaredNamespace}} + + Public Class VBClass + Public ReadOnly Property C1 As Class1 + End Class + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - public class Class1 - { - } -}"; + """ + namespace A.B.C + { + public class Class1 + { + } + } + """; var expectedSourceReference = -@" -Imports A.B.C + """ + Imports A.B.C -Public Class VBClass - Public ReadOnly Property C1 As Class1 -End Class"; + Public Class VBClass + Public ReadOnly Property C1 As Class1 + End Class + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1594,36 +1650,41 @@ public async Task ChangeNamespace_WithQualifiedReferencesInVBDocument() var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - public class Class1 - {{ - }} -}} - - - -Public Class VBClass - Public ReadOnly Property C1 As A.B.C.D.Class1 -End Class - -"; + $$""" + + + + namespace [||]{{declaredNamespace}} + { + public class Class1 + { + } + } + + + + Public Class VBClass + Public ReadOnly Property C1 As A.B.C.D.Class1 + End Class + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - public class Class1 - { - } -}"; + """ + namespace A.B.C + { + public class Class1 + { + } + } + """; var expectedSourceReference = -@"Public Class VBClass - Public ReadOnly Property C1 As A.B.C.Class1 -End Class"; + """ + Public Class VBClass + Public ReadOnly Property C1 As A.B.C.Class1 + End Class + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1634,37 +1695,39 @@ public async Task ChangeFromGlobalNamespace_WithReferencesInVBDocument() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var code = -$@" - - - -public class [||]Class1 -{{ -}} - - - - -Public Class VBClass - Public ReadOnly Property C1 As Class1 -End Class - -"; + $$""" + + + public class [||]Class1 + { + } + + + + Public Class VBClass + Public ReadOnly Property C1 As Class1 + End Class + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - public class Class1 - { - } -}"; + """ + namespace A.B.C + { + public class Class1 + { + } + } + """; var expectedSourceReference = -@" -Imports A.B.C + """ + Imports A.B.C -Public Class VBClass - Public ReadOnly Property C1 As Class1 -End Class"; + Public Class VBClass + Public ReadOnly Property C1 As Class1 + End Class + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1675,53 +1738,55 @@ public async Task ChangeFromGlobalNamespace_WithCredReferences() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -/// <summary> -/// See <see cref=""Class1""/> -/// </summary> -class [||]Class1 -{{ -}} - -namespace Foo -{{ - /// <summary> - /// See <see cref=""Class1""/> - /// </summary> - class Bar - {{ - }} -}} - -"; + $$""" + + + /// <summary> + /// See <see cref="Class1"/> + /// </summary> + class [||]Class1 + { + } + namespace Foo + { + /// <summary> + /// See <see cref="Class1"/> + /// </summary> + class Bar + { + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - - /// - /// See - /// - class Class1 - { - } -}"; + """ + namespace A.B.C + { + + /// + /// See + /// + class Class1 + { + } + } + """; var expectedSourceReference = -@" -using A.B.C; - -namespace Foo -{ - /// - /// See - /// - class Bar - { - } -}"; + """ + using A.B.C; + + namespace Foo + { + /// + /// See + /// + class Bar + { + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1733,36 +1798,39 @@ public async Task ChangeToGlobalNamespace_WithReferencesInVBDocument() var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - public class Class1 - {{ - }} -}} - - - -Imports {declaredNamespace} - -Public Class VBClass - Public ReadOnly Property C1 As Class1 -End Class - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + public class Class1 + { + } + } + + + Imports {{declaredNamespace}} + + Public Class VBClass + Public ReadOnly Property C1 As Class1 + End Class + + + """; var expectedSourceOriginal = -@"public class Class1 -{ -} -"; + """ + public class Class1 + { + } + + """; var expectedSourceReference = -@"Public Class VBClass - Public ReadOnly Property C1 As Class1 -End Class"; + """ + Public Class VBClass + Public ReadOnly Property C1 As Class1 + End Class + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1774,44 +1842,47 @@ public async Task ChangeToGlobalNamespace_WithReferenceAndConflictDeclarationInV var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - public class MyClass - {{ - }} -}} - - - -Namespace Foo - Public Class VBClass - Public ReadOnly Property C1 As Foo.Bar.Baz.MyClass - End Class - - Public Class MyClass - End Class -End Namespace - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + public class MyClass + { + } + } + + + Namespace Foo + Public Class VBClass + Public ReadOnly Property C1 As Foo.Bar.Baz.MyClass + End Class + + Public Class MyClass + End Class + End Namespace + + + """; var expectedSourceOriginal = -@"public class MyClass -{ -} -"; + """ + public class MyClass + { + } + + """; var expectedSourceReference = -@"Namespace Foo - Public Class VBClass - Public ReadOnly Property C1 As Global.MyClass - End Class - - Public Class MyClass - End Class -End Namespace"; + """ + Namespace Foo + Public Class VBClass + Public ReadOnly Property C1 As Global.MyClass + End Class + + Public Class MyClass + End Class + End Namespace + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1824,57 +1895,59 @@ public async Task ChangeToGlobalNamespace_WithCredReferences() var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - /// <summary> - /// See <see cref=""Class1""/> - /// See <see cref=""{declaredNamespace}.Class1""/> - /// </summary> - public class Class1 - {{ - }} -}} - -namespace Foo -{{ - using {declaredNamespace}; - - /// <summary> - /// See <see cref=""Class1""/> - /// See <see cref=""{declaredNamespace}.Class1""/> - /// </summary> - class RefClass - {{ - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + /// <summary> + /// See <see cref="Class1"/> + /// See <see cref="{{declaredNamespace}}.Class1"/> + /// </summary> + public class Class1 + { + } + } + namespace Foo + { + using {{declaredNamespace}}; + + /// <summary> + /// See <see cref="Class1"/> + /// See <see cref="{{declaredNamespace}}.Class1"/> + /// </summary> + class RefClass + { + } + } + + + """; var expectedSourceOriginal = -@"/// -/// See -/// See -/// -public class Class1 -{ -} -"; + """ + /// + /// See + /// See + /// + public class Class1 + { + } + + """; var expectedSourceReference = -@" -namespace Foo -{ - /// - /// See - /// See - /// - class RefClass - { - } -}"; + """ + namespace Foo + { + /// + /// See + /// See + /// + class RefClass + { + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1886,50 +1959,52 @@ public async Task ChangeNamespace_ExtensionMethodInReducedForm() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{defaultNamespace} -{{ - public static class Extensions - {{ - public static bool Foo(this Class1 c1) => true; - }} -}} - -namespace {defaultNamespace} -{{ - using System; - - public class Class1 - {{ - public bool Bar(Class1 c1) => c1.Foo(); - }} -}} - -"; + $$""" + + + namespace [||]{{defaultNamespace}} + { + public static class Extensions + { + public static bool Foo(this Class1 c1) => true; + } + } + namespace {{defaultNamespace}} + { + using System; + + public class Class1 + { + public bool Bar(Class1 c1) => c1.Foo(); + } + } + + + """; var expectedSourceOriginal = -$@"namespace A.B.C -{{ - public static class Extensions - {{ - public static bool Foo(this Class1 c1) => true; - }} -}}"; + $$""" + namespace A.B.C + { + public static class Extensions + { + public static bool Foo(this Class1 c1) => true; + } + } + """; var expectedSourceReference = -$@" -namespace {defaultNamespace} -{{ - using System; - using A.B.C; - - public class Class1 - {{ - public bool Bar(Class1 c1) => c1.Foo(); - }} -}}"; + $$""" + namespace {{defaultNamespace}} + { + using System; + using A.B.C; + + public class Class1 + { + public bool Bar(Class1 c1) => c1.Foo(); + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1941,50 +2016,52 @@ public async Task ChangeNamespace_ExternsionMethodInRegularForm() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]A -{{ - public static class Extensions - {{ - public static bool Foo(this Class1 c1) => true; - }} -}} - -using System; - -namespace A -{{ - public class Class1 - {{ - public bool Bar(Class1 c1) => Extensions.Foo(c1); - }} -}} - -"; + $$""" + + + namespace [||]A + { + public static class Extensions + { + public static bool Foo(this Class1 c1) => true; + } + } + using System; + + namespace A + { + public class Class1 + { + public bool Bar(Class1 c1) => Extensions.Foo(c1); + } + } + + + """; var expectedSourceOriginal = -$@"namespace A.B.C -{{ - public static class Extensions - {{ - public static bool Foo(this Class1 c1) => true; - }} -}}"; + $$""" + namespace A.B.C + { + public static class Extensions + { + public static bool Foo(this Class1 c1) => true; + } + } + """; var expectedSourceReference = -$@" -using System; -using A.B.C; - -namespace A -{{ - public class Class1 - {{ - public bool Bar(Class1 c1) => Extensions.Foo(c1); - }} -}}"; + $$""" + using System; + using A.B.C; + + namespace A + { + public class Class1 + { + public bool Bar(Class1 c1) => Extensions.Foo(c1); + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -1996,56 +2073,58 @@ public async Task ChangeNamespace_ContainsBothTypeAndExternsionMethod() var (folder, filePath) = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]A -{{ - public static class Extensions - {{ - public static bool Foo(this Class1 c1) => true; - }} - - public class Class2 - {{ }} -}} - -using System; - -namespace A -{{ - public class Class1 - {{ - public bool Bar(Class1 c1, Class2 c2) => c2 == null ? c1.Foo() : true; - }} -}} - -"; + $$""" + + + namespace [||]A + { + public static class Extensions + { + public static bool Foo(this Class1 c1) => true; + } + + public class Class2 + { } + } + using System; + + namespace A + { + public class Class1 + { + public bool Bar(Class1 c1, Class2 c2) => c2 == null ? c1.Foo() : true; + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - public static class Extensions - { - public static bool Foo(this Class1 c1) => true; - } - - public class Class2 - { } -}"; + """ + namespace A.B.C + { + public static class Extensions + { + public static bool Foo(this Class1 c1) => true; + } + + public class Class2 + { } + } + """; var expectedSourceReference = -@" -using System; -using A.B.C; - -namespace A -{ - public class Class1 - { - public bool Bar(Class1 c1, Class2 c2) => c2 == null ? c1.Foo() : true; - } -}"; + """ + using System; + using A.B.C; + + namespace A + { + public class Class1 + { + public bool Bar(Class1 c1, Class2 c2) => c2 == null ? c1.Foo() : true; + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -2057,52 +2136,53 @@ public async Task ChangeNamespace_WithExtensionMethodReferencesInVBDocument() var (folder, filePath) = CreateDocumentFilePath([], "File1.cs"); var code = -$@" - - - -using System; - -namespace [||]{declaredNamespace} -{{ - public static class Extensions - {{ - public static bool Foo(this String s) => true; - }} -}} - - - -Imports {declaredNamespace} - -Public Class VBClass - Public Function Foo(s As string) As Boolean - Return s.Foo() - End Function -End Class - -"; + $$""" + + + using System; + + namespace [||]{{declaredNamespace}} + { + public static class Extensions + { + public static bool Foo(this String s) => true; + } + } + + + Imports {{declaredNamespace}} + + Public Class VBClass + Public Function Foo(s As string) As Boolean + Return s.Foo() + End Function + End Class + + + """; var expectedSourceOriginal = -$@" -using System; - -namespace {defaultNamespace} -{{ - public static class Extensions - {{ - public static bool Foo(this string s) => true; - }} -}}"; + $$""" + using System; + + namespace {{defaultNamespace}} + { + public static class Extensions + { + public static bool Foo(this string s) => true; + } + } + """; var expectedSourceReference = -$@" -Imports {defaultNamespace} - -Public Class VBClass - Public Function Foo(s As string) As Boolean - Return s.Foo() - End Function -End Class"; + $""" + Imports {defaultNamespace} + + Public Class VBClass + Public Function Foo(s As string) As Boolean + Return s.Foo() + End Function + End Class + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -2115,57 +2195,59 @@ public async Task ChangeNamespace_WithMemberAccessReferencesInOtherDocument() var documentPath1 = CreateDocumentFilePath(["B", "C"], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - enum Enum1 - {{ - A, - B, - C - }} -}} - -namespace Foo -{{ - class RefClass - {{ - Enum1 M1() - {{ - return {declaredNamespace}.Enum1.A; - }} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + enum Enum1 + { + A, + B, + C + } + } + namespace Foo + { + class RefClass + { + Enum1 M1() + { + return {{declaredNamespace}}.Enum1.A; + } + } + } + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - enum Enum1 - { - A, - B, - C - } -}"; + """ + namespace A.B.C + { + enum Enum1 + { + A, + B, + C + } + } + """; var expectedSourceReference = -@" -using A.B.C; - -namespace Foo -{ - class RefClass - { - Enum1 M1() - { - return Enum1.A; - } - } -}"; + """ + using A.B.C; + + namespace Foo + { + class RefClass + { + Enum1 M1() + { + return Enum1.A; + } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -2178,52 +2260,55 @@ public async Task ChangeToGlobalNamespace_WithMemberAccessReferencesInOtherDocum var documentPath1 = CreateDocumentFilePath([], "File1.cs"); var documentPath2 = CreateDocumentFilePath([], "File2.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - enum Enum1 - {{ - A, - B, - C - }} -}} - -namespace Foo -{{ - class RefClass - {{ - Enum1 M1() - {{ - return {declaredNamespace}.Enum1.A; - }} - }} -}} - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + enum Enum1 + { + A, + B, + C + } + } + namespace Foo + { + class RefClass + { + Enum1 M1() + { + return {{declaredNamespace}}.Enum1.A; + } + } + } + + + """; var expectedSourceOriginal = -@"enum Enum1 -{ - A, - B, - C -} -"; + """ + enum Enum1 + { + A, + B, + C + } + + """; var expectedSourceReference = -@"namespace Foo -{ - class RefClass - { - Enum1 M1() - { - return Enum1.A; - } - } -}"; + """ + namespace Foo + { + class RefClass + { + Enum1 M1() + { + return Enum1.A; + } + } + } + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -2235,46 +2320,51 @@ public async Task ChangeNamespace_WithMemberAccessReferencesInVBDocument() var documentPath1 = CreateDocumentFilePath([], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - public enum Enum1 - {{ - A, - B, - C - }} -}} - - - -Public Class VBClass - Sub M() - Dim x = A.B.C.D.Enum1.A - End Sub -End Class - -"; + $$""" + + + + namespace [||]{{declaredNamespace}} + { + public enum Enum1 + { + A, + B, + C + } + } + + + + Public Class VBClass + Sub M() + Dim x = A.B.C.D.Enum1.A + End Sub + End Class + + + """; var expectedSourceOriginal = -@"namespace A.B.C -{ - public enum Enum1 - { - A, - B, - C - } -}"; + """ + namespace A.B.C + { + public enum Enum1 + { + A, + B, + C + } + } + """; var expectedSourceReference = -@"Public Class VBClass - Sub M() - Dim x = A.B.C.Enum1.A - End Sub -End Class"; + """ + Public Class VBClass + Sub M() + Dim x = A.B.C.Enum1.A + End Sub + End Class + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } @@ -2286,44 +2376,47 @@ public async Task ChangeToGlobalNamespace_WithMemberAccessReferencesInVBDocument var documentPath1 = CreateDocumentFilePath([], "File1.cs"); var code = -$@" - - - -namespace [||]{declaredNamespace} -{{ - public enum Enum1 - {{ - A, - B, - C - }} -}} - - - -Public Class VBClass - Sub M() - Dim x = A.B.C.D.Enum1.A - End Sub -End Class - -"; + $$""" + + + namespace [||]{{declaredNamespace}} + { + public enum Enum1 + { + A, + B, + C + } + } + + + Public Class VBClass + Sub M() + Dim x = A.B.C.D.Enum1.A + End Sub + End Class + + + """; var expectedSourceOriginal = -@"public enum Enum1 -{ - A, - B, - C -} -"; + """ + public enum Enum1 + { + A, + B, + C + } + + """; var expectedSourceReference = -@"Public Class VBClass - Sub M() - Dim x = Enum1.A - End Sub -End Class"; + """ + Public Class VBClass + Sub M() + Dim x = Enum1.A + End Sub + End Class + """; await TestChangeNamespaceAsync(code, expectedSourceOriginal, expectedSourceReference); } From 36554b31cc8a361bf75a7493f4d3caa9756c7c15 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 22 Nov 2024 18:11:47 -0800 Subject: [PATCH 3/4] Fix --- .../CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs b/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs index 8461a149443d3..2274838ef545f 100644 --- a/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs +++ b/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs @@ -301,7 +301,7 @@ public async Task MoveTypeWithWithContainerNamespace() @"namespace N1 { [||]class Class1 { } - class Class2 { } + class Class2 { } }"; var codeAfterMove = From 3ffa7c77315546465640e86d2c5adc34d01ca981 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 22 Nov 2024 18:13:11 -0800 Subject: [PATCH 4/4] Use raw strings in tests --- .../MoveType/MoveTypeTests.MoveToNewFile.cs | 2326 +++++++++-------- 1 file changed, 1295 insertions(+), 1031 deletions(-) diff --git a/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs b/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs index 2274838ef545f..12cfecdc623d2 100644 --- a/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs +++ b/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs @@ -2,8 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. -#nullable disable - using System.Collections.Immutable; using System.Threading.Tasks; using Microsoft.CodeAnalysis.Formatting; @@ -14,13 +12,13 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeActions.MoveType; [Trait(Traits.Feature, Traits.Features.CodeActionsMoveType)] -public partial class MoveTypeTests : CSharpMoveTypeTestsBase +public sealed partial class MoveTypeTests : CSharpMoveTypeTestsBase { [WpfFact] public async Task TestMissing_OnMatchingFileName() { var code = -@"[||]class test1 { }"; + @"[||]class test1 { }"; await TestMissingInRegularAndScriptAsync(code); } @@ -29,10 +27,12 @@ public async Task TestMissing_OnMatchingFileName() public async Task TestMissing_Nested_OnMatchingFileName_Simple() { var code = -@"class outer -{ - [||]class test1 { } -}"; + """ + class outer + { + [||]class test1 { } + } + """; await TestMissingInRegularAndScriptAsync(code); } @@ -41,7 +41,7 @@ public async Task TestMissing_Nested_OnMatchingFileName_Simple() public async Task TestMatchingFileName_CaseSensitive() { var code = -@"[||]class Test1 { }"; + @"[||]class Test1 { }"; await TestActionCountAsync(code, count: 2); } @@ -50,8 +50,10 @@ public async Task TestMatchingFileName_CaseSensitive() public async Task TestForSpans1() { var code = -@"[|clas|]s Class1 { } - class Class2 { }"; + """ + [|clas|]s Class1 { } + class Class2 { } + """; await TestActionCountAsync(code, count: 3); } @@ -60,13 +62,17 @@ class Class2 { }"; public async Task TestForSpans2() { var code = -@"[||]class Class1 { } - class Class2 { }"; + """ + [||]class Class1 { } + class Class2 { } + """; var codeAfterMove = @"class Class2 { }"; var expectedDocumentName = "Class1.cs"; - var destinationDocumentText = @"class Class1 { } -"; + var destinationDocumentText = """ + class Class1 { } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -75,21 +81,27 @@ class Class2 { }"; public async Task TestMoveToNewFileWithFolders() { var code = -@" - - - -[||]class Class1 { } -class Class2 { } - - -"; - var codeAfterMove = @"class Class2 { } - "; + """ + + + + + [||]class Class1 { } + class Class2 { } + + + + """; + var codeAfterMove = """ + class Class2 { } + + """; var expectedDocumentName = "Class1.cs"; - var destinationDocumentText = @"class Class1 { } - "; + var destinationDocumentText = """ + class Class1 { } + + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, @@ -100,8 +112,10 @@ await TestMoveTypeToNewFileAsync( public async Task TestForSpans3() { var code = -@"[|class Class1|] { } -class Class2 { }"; + """ + [|class Class1|] { } + class Class2 { } + """; await TestActionCountAsync(code, count: 3); } @@ -110,13 +124,17 @@ class Class2 { }"; public async Task TestForSpans4() { var code = -@"class Class1[||] { } -class Class2 { }"; + """ + class Class1[||] { } + class Class2 { } + """; var codeAfterMove = @"class Class2 { }"; var expectedDocumentName = "Class1.cs"; - var destinationDocumentText = @"class Class1 { } -"; + var destinationDocumentText = """ + class Class1 { } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -125,13 +143,17 @@ class Class2 { }"; public async Task MoveTypeWithNoContainerNamespace() { var code = -@"[||]class Class1 { } -class Class2 { }"; + """ + [||]class Class1 { } + class Class2 { } + """; var codeAfterMove = @"class Class2 { }"; var expectedDocumentName = "Class1.cs"; - var destinationDocumentText = @"class Class1 { } -"; + var destinationDocumentText = """ + class Class1 { } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -140,22 +162,28 @@ class Class2 { }"; public async Task MoveTypeWithWithUsingsAndNoContainerNamespace() { var code = -@"// Banner Text -using System; + """ + // Banner Text + using System; -[||]class Class1 { } -class Class2 { }"; + [||]class Class1 { } + class Class2 { } + """; var codeAfterMove = -@"// Banner Text -using System; -class Class2 { }"; + """ + // Banner Text + using System; + class Class2 { } + """; var expectedDocumentName = "Class1.cs"; var destinationDocumentText = -@"// Banner Text -class Class1 { } -"; + """ + // Banner Text + class Class1 { } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -164,35 +192,41 @@ class Class1 { } public async Task MoveTypeWithWithMembers() { var code = -@"// Banner Text -using System; + """ + // Banner Text + using System; -[||]class Class1 -{ - void Print(int x) - { - Console.WriteLine(x); - } -} -class Class2 { }"; + [||]class Class1 + { + void Print(int x) + { + Console.WriteLine(x); + } + } + class Class2 { } + """; var codeAfterMove = -@"// Banner Text -class Class2 { }"; + """ + // Banner Text + class Class2 { } + """; var expectedDocumentName = "Class1.cs"; var destinationDocumentText = -@"// Banner Text -using System; + """ + // Banner Text + using System; -class Class1 -{ - void Print(int x) - { - Console.WriteLine(x); - } -} -"; + class Class1 + { + void Print(int x) + { + Console.WriteLine(x); + } + } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -201,50 +235,56 @@ void Print(int x) public async Task MoveTypeWithWithMembers2() { var code = -@"// Banner Text -using System; + """ + // Banner Text + using System; -[||]class Class1 -{ - void Print(int x) - { - Console.WriteLine(x); - } -} + [||]class Class1 + { + void Print(int x) + { + Console.WriteLine(x); + } + } -class Class2 -{ - void Print(int x) - { - Console.WriteLine(x); - } -}"; + class Class2 + { + void Print(int x) + { + Console.WriteLine(x); + } + } + """; var codeAfterMove = -@"// Banner Text -using System; + """ + // Banner Text + using System; -class Class2 -{ - void Print(int x) - { - Console.WriteLine(x); - } -}"; + class Class2 + { + void Print(int x) + { + Console.WriteLine(x); + } + } + """; var expectedDocumentName = "Class1.cs"; var destinationDocumentText = -@"// Banner Text -using System; + """ + // Banner Text + using System; -class Class1 -{ - void Print(int x) - { - Console.WriteLine(x); - } -} -"; + class Class1 + { + void Print(int x) + { + Console.WriteLine(x); + } + } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -253,13 +293,17 @@ void Print(int x) public async Task MoveAnInterface() { var code = -@"[||]interface IMoveType { } -class Class2 { }"; + """ + [||]interface IMoveType { } + class Class2 { } + """; var codeAfterMove = @"class Class2 { }"; var expectedDocumentName = "IMoveType.cs"; - var destinationDocumentText = @"interface IMoveType { } -"; + var destinationDocumentText = """ + interface IMoveType { } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -268,13 +312,17 @@ class Class2 { }"; public async Task MoveAStruct() { var code = -@"[||]struct MyStruct { } -class Class2 { }"; + """ + [||]struct MyStruct { } + class Class2 { } + """; var codeAfterMove = @"class Class2 { }"; var expectedDocumentName = "MyStruct.cs"; - var destinationDocumentText = @"struct MyStruct { } -"; + var destinationDocumentText = """ + struct MyStruct { } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -283,13 +331,17 @@ class Class2 { }"; public async Task MoveAnEnum() { var code = -@"[||]enum MyEnum { } -class Class2 { }"; + """ + [||]enum MyEnum { } + class Class2 { } + """; var codeAfterMove = @"class Class2 { }"; var expectedDocumentName = "MyEnum.cs"; - var destinationDocumentText = @"enum MyEnum { } -"; + var destinationDocumentText = """ + enum MyEnum { } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -298,25 +350,31 @@ class Class2 { }"; public async Task MoveTypeWithWithContainerNamespace() { var code = -@"namespace N1 -{ - [||]class Class1 { } - class Class2 { } -}"; + """ + namespace N1 + { + [||]class Class1 { } + class Class2 { } + } + """; var codeAfterMove = -@"namespace N1 -{ - class Class2 { } -}"; + """ + namespace N1 + { + class Class2 { } + } + """; var expectedDocumentName = "Class1.cs"; var destinationDocumentText = -@"namespace N1 -{ - class Class1 { } -}"; + """ + namespace N1 + { + class Class1 { } + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -324,24 +382,30 @@ class Class1 { } public async Task MoveTypeWithWithFileScopedNamespace() { var code = -@"namespace N1; + """ + namespace N1; -[||]class Class1 { } -class Class2 { } -"; + [||]class Class1 { } + class Class2 { } + + """; var codeAfterMove = -@"namespace N1; -class Class2 { } -"; + """ + namespace N1; + class Class2 { } + + """; var expectedDocumentName = "Class1.cs"; var destinationDocumentText = -@"namespace N1; + """ + namespace N1; -class Class1 { } -"; + class Class1 { } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -349,35 +413,41 @@ class Class1 { } public async Task MoveNestedTypeToNewFile_Simple() { var code = -@"namespace N1 -{ - class Class1 - { - [||]class Class2 { } - } - -}"; + """ + namespace N1 + { + class Class1 + { + [||]class Class2 { } + } + + } + """; var codeAfterMove = -@"namespace N1 -{ - partial class Class1 - { - } - -}"; + """ + namespace N1 + { + partial class Class1 + { + } + + } + """; var expectedDocumentName = "Class2.cs"; var destinationDocumentText = -@"namespace N1 -{ - partial class Class1 - { - class Class2 { } - } - -}"; + """ + namespace N1 + { + partial class Class1 + { + class Class2 { } + } + + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -385,35 +455,41 @@ class Class2 { } public async Task MoveNestedTypePreserveModifiers() { var code = -@"namespace N1 -{ - abstract class Class1 - { - [||]class Class2 { } - } - -}"; + """ + namespace N1 + { + abstract class Class1 + { + [||]class Class2 { } + } + + } + """; var codeAfterMove = -@"namespace N1 -{ - abstract partial class Class1 - { - } - -}"; + """ + namespace N1 + { + abstract partial class Class1 + { + } + + } + """; var expectedDocumentName = "Class2.cs"; var destinationDocumentText = -@"namespace N1 -{ - abstract partial class Class1 - { - class Class2 { } - } - -}"; + """ + namespace N1 + { + abstract partial class Class1 + { + class Class2 { } + } + + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -421,39 +497,45 @@ class Class2 { } public async Task MoveNestedTypeToNewFile_Attributes1() { var code = -@"namespace N1 -{ - [Outer] - class Class1 - { - [Inner] - [||]class Class2 { } - } - -}"; + """ + namespace N1 + { + [Outer] + class Class1 + { + [Inner] + [||]class Class2 { } + } + + } + """; var codeAfterMove = -@"namespace N1 -{ - [Outer] - partial class Class1 - { - } - -}"; + """ + namespace N1 + { + [Outer] + partial class Class1 + { + } + + } + """; var expectedDocumentName = "Class2.cs"; var destinationDocumentText = -@"namespace N1 -{ - partial class Class1 - { - [Inner] - class Class2 { } - } - -}"; + """ + namespace N1 + { + partial class Class1 + { + [Inner] + class Class2 { } + } + + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -461,40 +543,46 @@ class Class2 { } public async Task MoveNestedTypeToNewFile_Comments1() { var code = -@"namespace N1 -{ - /// Outer doc comment. - class Class1 - { - /// Inner doc comment - [||]class Class2 - { - } - } -}"; + """ + namespace N1 + { + /// Outer doc comment. + class Class1 + { + /// Inner doc comment + [||]class Class2 + { + } + } + } + """; var codeAfterMove = -@"namespace N1 -{ - /// Outer doc comment. - partial class Class1 - { - } -}"; + """ + namespace N1 + { + /// Outer doc comment. + partial class Class1 + { + } + } + """; var expectedDocumentName = "Class2.cs"; var destinationDocumentText = -@"namespace N1 -{ - partial class Class1 - { - /// Inner doc comment - class Class2 - { - } - } -}"; + """ + namespace N1 + { + partial class Class1 + { + /// Inner doc comment + class Class2 + { + } + } + } + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -503,35 +591,41 @@ await TestMoveTypeToNewFileAsync( public async Task MoveNestedTypeToNewFile_Simple_DottedName() { var code = -@"namespace N1 -{ - class Class1 - { - [||]class Class2 { } - } - -}"; + """ + namespace N1 + { + class Class1 + { + [||]class Class2 { } + } + + } + """; var codeAfterMove = -@"namespace N1 -{ - partial class Class1 - { - } - -}"; + """ + namespace N1 + { + partial class Class1 + { + } + + } + """; var expectedDocumentName = "Class1.Class2.cs"; var destinationDocumentText = -@"namespace N1 -{ - partial class Class1 - { - class Class2 { } - } - -}"; + """ + namespace N1 + { + partial class Class1 + { + class Class2 { } + } + + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText, index: 1); } @@ -539,27 +633,33 @@ class Class2 { } public async Task MoveNestedTypeToNewFile_Simple_DottedName_WithPrimaryConstructor() { var code = -@"internal class Outer() -{ - private class Inner[||] - { - } -}"; + """ + internal class Outer() + { + private class Inner[||] + { + } + } + """; var codeAfterMove = -@"internal partial class Outer() -{ -}"; + """ + internal partial class Outer() + { + } + """; var expectedDocumentName = "Outer.Inner.cs"; var destinationDocumentText = -@"internal partial class Outer -{ - private class Inner - { - } -}"; + """ + internal partial class Outer + { + private class Inner + { + } + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText, index: 1); } @@ -567,42 +667,48 @@ private class Inner public async Task MoveNestedTypeToNewFile_ParentHasOtherMembers() { var code = -@"namespace N1 -{ - class Class1 - { - private int _field1; + """ + namespace N1 + { + class Class1 + { + private int _field1; - [||]class Class2 { } + [||]class Class2 { } - public void Method1() { } - } - -}"; + public void Method1() { } + } + + } + """; var codeAfterMove = -@"namespace N1 -{ - partial class Class1 - { - private int _field1; + """ + namespace N1 + { + partial class Class1 + { + private int _field1; - public void Method1() { } - } - -}"; + public void Method1() { } + } + + } + """; var expectedDocumentName = "Class2.cs"; var destinationDocumentText = -@"namespace N1 -{ - partial class Class1 - { - class Class2 { } - } - -}"; + """ + namespace N1 + { + partial class Class1 + { + class Class2 { } + } + + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -610,49 +716,55 @@ class Class2 { } public async Task MoveNestedTypeToNewFile_HasOtherTopLevelMembers() { var code = -@"namespace N1 -{ - class Class1 - { - private int _field1; + """ + namespace N1 + { + class Class1 + { + private int _field1; - [||]class Class2 { } + [||]class Class2 { } - public void Method1() { } - } + public void Method1() { } + } - internal class Class3 - { - private void Method1() { } - } -}"; + internal class Class3 + { + private void Method1() { } + } + } + """; var codeAfterMove = -@"namespace N1 -{ - partial class Class1 - { - private int _field1; + """ + namespace N1 + { + partial class Class1 + { + private int _field1; - public void Method1() { } - } + public void Method1() { } + } - internal class Class3 - { - private void Method1() { } - } -}"; + internal class Class3 + { + private void Method1() { } + } + } + """; var expectedDocumentName = "Class2.cs"; var destinationDocumentText = -@"namespace N1 -{ - partial class Class1 - { - class Class2 { } - } -}"; + """ + namespace N1 + { + partial class Class1 + { + class Class2 { } + } + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -660,161 +772,173 @@ class Class2 { } public async Task MoveNestedTypeToNewFile_HasMembers() { var code = -@"namespace N1 -{ - class Class1 - { - private int _field1; + """ + namespace N1 + { + class Class1 + { + private int _field1; - [||]class Class2 - { - private string _field1; - public void InnerMethod() { } - } + [||]class Class2 + { + private string _field1; + public void InnerMethod() { } + } - public void Method1() { } - } -}"; + public void Method1() { } + } + } + """; var codeAfterMove = -@"namespace N1 -{ - partial class Class1 - { - private int _field1; + """ + namespace N1 + { + partial class Class1 + { + private int _field1; - public void Method1() { } - } -}"; + public void Method1() { } + } + } + """; var expectedDocumentName = "Class2.cs"; var destinationDocumentText = -@"namespace N1 -{ - partial class Class1 - { - class Class2 - { - private string _field1; - public void InnerMethod() { } - } - } -}"; - await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); - } + """ + namespace N1 + { + partial class Class1 + { + class Class2 + { + private string _field1; + public void InnerMethod() { } + } + } + } + """; + await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); + } [WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/13969")] public async Task MoveTypeInFileWithComplexHierarchy() { var code = -@"namespace OuterN1.N1 -{ - namespace InnerN2.N2 - { - class OuterClass1 - { - class InnerClass2 + """ + namespace OuterN1.N1 { - } - } - } + namespace InnerN2.N2 + { + class OuterClass1 + { + class InnerClass2 + { + } + } + } - namespace InnerN3.N3 - { - class OuterClass2 - { - [||]class InnerClass2 - { - class InnerClass3 + namespace InnerN3.N3 { + class OuterClass2 + { + [||]class InnerClass2 + { + class InnerClass3 + { + } + } + + class InnerClass4 + { + } + } + + class OuterClass3 + { + } } } - class InnerClass4 + namespace OuterN2.N2 { + namespace InnerN3.N3 + { + class OuterClass5 { + class InnerClass6 { + } + } + } } - } - class OuterClass3 - { - } - } -} - -namespace OuterN2.N2 -{ - namespace InnerN3.N3 - { - class OuterClass5 { - class InnerClass6 { - } - } - } -} -"; + """; var codeAfterMove = -@"namespace OuterN1.N1 -{ - namespace InnerN2.N2 - { - class OuterClass1 - { - class InnerClass2 + """ + namespace OuterN1.N1 { - } - } - } + namespace InnerN2.N2 + { + class OuterClass1 + { + class InnerClass2 + { + } + } + } - namespace InnerN3.N3 - { - partial class OuterClass2 - { + namespace InnerN3.N3 + { + partial class OuterClass2 + { - class InnerClass4 - { - } - } + class InnerClass4 + { + } + } - class OuterClass3 - { - } - } -} + class OuterClass3 + { + } + } + } -namespace OuterN2.N2 -{ - namespace InnerN3.N3 - { - class OuterClass5 { - class InnerClass6 { + namespace OuterN2.N2 + { + namespace InnerN3.N3 + { + class OuterClass5 { + class InnerClass6 { + } + } + } } - } - } -} -"; + + """; var expectedDocumentName = "InnerClass2.cs"; var destinationDocumentText = -@"namespace OuterN1.N1 -{ - - namespace InnerN3.N3 - { - partial class OuterClass2 - { - class InnerClass2 + """ + namespace OuterN1.N1 { - class InnerClass3 + + namespace InnerN3.N3 { + partial class OuterClass2 + { + class InnerClass2 + { + class InnerClass3 + { + } + } + } } } - } - } -} -"; + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -822,40 +946,46 @@ class InnerClass3 public async Task MoveTypeUsings1() { var code = -@" -// Only used by inner type. -using System; + """ -// Unused by both types. -using System.Collections; + // Only used by inner type. + using System; -class Outer { - [||]class Inner { - DateTime d; - } -}"; - var codeAfterMove = @" -// Only used by inner type. + // Unused by both types. + using System.Collections; + + class Outer { + [||]class Inner { + DateTime d; + } + } + """; + var codeAfterMove = """ -// Unused by both types. -using System.Collections; + // Only used by inner type. -partial class Outer { -}"; + // Unused by both types. + using System.Collections; + + partial class Outer { + } + """; var expectedDocumentName = "Inner.cs"; var destinationDocumentText = -@" -// Only used by inner type. -using System; + """ -// Unused by both types. + // Only used by inner type. + using System; -partial class Outer { - class Inner { - DateTime d; - } -}"; + // Unused by both types. + + partial class Outer { + class Inner { + DateTime d; + } + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -864,33 +994,39 @@ class Inner { public async Task TestLeadingTrivia1() { var code = -@" -class Outer -{ - class Inner1 - { - } + """ - [||]class Inner2 - { - } -}"; - var codeAfterMove = @" -partial class Outer -{ - class Inner1 - { - } -}"; + class Outer + { + class Inner1 + { + } + + [||]class Inner2 + { + } + } + """; + var codeAfterMove = """ + + partial class Outer + { + class Inner1 + { + } + } + """; var expectedDocumentName = "Inner2.cs"; - var destinationDocumentText = @" -partial class Outer -{ - class Inner2 - { - } -}"; + var destinationDocumentText = """ + + partial class Outer + { + class Inner2 + { + } + } + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText); @@ -900,34 +1036,40 @@ await TestMoveTypeToNewFileAsync( public async Task TestInsertFinalNewLine() { var code = -@" -class Outer -{ - class Inner1 - { - } + """ - [||]class Inner2 - { - } -}"; - var codeAfterMove = @" -partial class Outer -{ - class Inner1 - { - } -}"; + class Outer + { + class Inner1 + { + } + + [||]class Inner2 + { + } + } + """; + var codeAfterMove = """ + + partial class Outer + { + class Inner1 + { + } + } + """; var expectedDocumentName = "Inner2.cs"; - var destinationDocumentText = @" -partial class Outer -{ - class Inner2 - { - } -} -"; + var destinationDocumentText = """ + + partial class Outer + { + class Inner2 + { + } + } + + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText, @@ -938,33 +1080,39 @@ await TestMoveTypeToNewFileAsync( public async Task TestInsertFinalNewLine2() { var code = -@" -class Outer -{ - class Inner1 - { - } + """ - [||]class Inner2 - { - } -}"; - var codeAfterMove = @" -partial class Outer -{ - class Inner1 - { - } -}"; + class Outer + { + class Inner1 + { + } + + [||]class Inner2 + { + } + } + """; + var codeAfterMove = """ + + partial class Outer + { + class Inner1 + { + } + } + """; var expectedDocumentName = "Inner2.cs"; - var destinationDocumentText = @" -partial class Outer -{ - class Inner2 - { - } -}"; + var destinationDocumentText = """ + + partial class Outer + { + class Inner2 + { + } + } + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText, @@ -975,26 +1123,32 @@ await TestMoveTypeToNewFileAsync( public async Task MoveTypeRemoveOuterInheritanceTypes() { var code = -@" -class Outer : IComparable { - [||]class Inner : IWhatever { - DateTime d; - } -}"; + """ + + class Outer : IComparable { + [||]class Inner : IWhatever { + DateTime d; + } + } + """; var codeAfterMove = -@" -partial class Outer : IComparable { -}"; + """ + + partial class Outer : IComparable { + } + """; var expectedDocumentName = "Inner.cs"; var destinationDocumentText = -@" -partial class Outer -{ - class Inner : IWhatever { - DateTime d; - } -}"; + """ + + partial class Outer + { + class Inner : IWhatever { + DateTime d; + } + } + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText); @@ -1004,49 +1158,55 @@ await TestMoveTypeToNewFileAsync( public async Task MoveTypeWithDirectives1() { var code = -@"using System; + """ + using System; -namespace N -{ - class Program - { - static void Main() - { - } - } -} + namespace N + { + class Program + { + static void Main() + { + } + } + } -#if true -public class [||]Inner -{ + #if true + public class [||]Inner + { -} -#endif"; + } + #endif + """; var codeAfterMove = - @"using System; + """ + using System; -namespace N -{ - class Program - { - static void Main() + namespace N { + class Program + { + static void Main() + { + } + } } - } -} -#if true -#endif"; + #if true + #endif + """; var expectedDocumentName = "Inner.cs"; var destinationDocumentText = -@" -#if true -public class Inner -{ + """ -} -#endif"; + #if true + public class Inner + { + + } + #endif + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText); @@ -1056,54 +1216,60 @@ await TestMoveTypeToNewFileAsync( public async Task MoveTypeWithDirectives2() { var code = -@"using System; + """ + using System; -namespace N -{ - class Program - { - static void Main() - { - } + namespace N + { + class Program + { + static void Main() + { + } -#if true - public class [||]Inner - { + #if true + public class [||]Inner + { - } -#endif - } -}"; + } + #endif + } + } + """; var codeAfterMove = - @"using System; + """ + using System; -namespace N -{ - partial class Program - { - static void Main() + namespace N { - } + partial class Program + { + static void Main() + { + } -#if true -#endif - } -}"; + #if true + #endif + } + } + """; var expectedDocumentName = "Inner.cs"; var destinationDocumentText = -@"namespace N -{ - partial class Program - { -#if true - public class Inner - { + """ + namespace N + { + partial class Program + { + #if true + public class Inner + { - } -#endif - } -}"; + } + #endif + } + } + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText); @@ -1113,49 +1279,55 @@ await TestMoveTypeToNewFileAsync( public async Task TestLeadingBlankLines1() { var code = -@"// Banner Text -using System; + """ + // Banner Text + using System; -[||]class Class1 -{ - void Foo() - { - Console.WriteLine(); - } -} + [||]class Class1 + { + void Foo() + { + Console.WriteLine(); + } + } -class Class2 -{ - void Foo() - { - Console.WriteLine(); - } -} -"; - var codeAfterMove = @"// Banner Text -using System; + class Class2 + { + void Foo() + { + Console.WriteLine(); + } + } -class Class2 -{ - void Foo() - { - Console.WriteLine(); - } -} -"; + """; + var codeAfterMove = """ + // Banner Text + using System; + + class Class2 + { + void Foo() + { + Console.WriteLine(); + } + } + + """; var expectedDocumentName = "Class1.cs"; - var destinationDocumentText = @"// Banner Text -using System; + var destinationDocumentText = """ + // Banner Text + using System; -class Class1 -{ - void Foo() - { - Console.WriteLine(); - } -} -"; + class Class1 + { + void Foo() + { + Console.WriteLine(); + } + } + + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText); @@ -1165,49 +1337,55 @@ await TestMoveTypeToNewFileAsync( public async Task TestLeadingBlankLines2() { var code = -@"// Banner Text -using System; + """ + // Banner Text + using System; -class Class1 -{ - void Foo() - { - Console.WriteLine(); - } -} + class Class1 + { + void Foo() + { + Console.WriteLine(); + } + } -[||]class Class2 -{ - void Foo() - { - Console.WriteLine(); - } -} -"; - var codeAfterMove = @"// Banner Text -using System; + [||]class Class2 + { + void Foo() + { + Console.WriteLine(); + } + } -class Class1 -{ - void Foo() - { - Console.WriteLine(); - } -} -"; + """; + var codeAfterMove = """ + // Banner Text + using System; + + class Class1 + { + void Foo() + { + Console.WriteLine(); + } + } + + """; var expectedDocumentName = "Class2.cs"; - var destinationDocumentText = @"// Banner Text -using System; + var destinationDocumentText = """ + // Banner Text + using System; -class Class2 -{ - void Foo() - { - Console.WriteLine(); - } -} -"; + class Class2 + { + void Foo() + { + Console.WriteLine(); + } + } + + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText); @@ -1217,49 +1395,55 @@ await TestMoveTypeToNewFileAsync( public async Task TestLeadingCommentInContainer() { var code = -@"// Banner Text -using System; + """ + // Banner Text + using System; + + class Class1 + // Leading comment + { + class [||]Class2 + { + } -class Class1 -// Leading comment -{ - class [||]Class2 - { - } + void Foo() + { + Console.WriteLine(); + } - void Foo() - { - Console.WriteLine(); - } + public int I() => 5; + } - public int I() => 5; -} -"; - var codeAfterMove = @"// Banner Text -using System; + """; + var codeAfterMove = """ + // Banner Text + using System; -partial class Class1 -// Leading comment -{ + partial class Class1 + // Leading comment + { - void Foo() - { - Console.WriteLine(); - } + void Foo() + { + Console.WriteLine(); + } - public int I() => 5; -} -"; + public int I() => 5; + } + + """; var expectedDocumentName = "Class2.cs"; - var destinationDocumentText = @"// Banner Text -partial class Class1 -{ - class Class2 - { - } -} -"; + var destinationDocumentText = """ + // Banner Text + partial class Class1 + { + class Class2 + { + } + } + + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText); @@ -1269,47 +1453,53 @@ await TestMoveTypeToNewFileAsync( public async Task TestLeadingCommentInContainer2() { var code = -@"// Banner Text -using System; + """ + // Banner Text + using System; -class Class1 -{ // Leading comment - class [||]Class2 - { - } + class Class1 + { // Leading comment + class [||]Class2 + { + } - void Foo() - { - Console.WriteLine(); - } + void Foo() + { + Console.WriteLine(); + } - public int I() => 5; -} -"; - var codeAfterMove = @"// Banner Text -using System; + public int I() => 5; + } -partial class Class1 -{ // Leading comment + """; + var codeAfterMove = """ + // Banner Text + using System; - void Foo() - { - Console.WriteLine(); - } + partial class Class1 + { // Leading comment - public int I() => 5; -} -"; + void Foo() + { + Console.WriteLine(); + } + + public int I() => 5; + } + + """; var expectedDocumentName = "Class2.cs"; - var destinationDocumentText = @"// Banner Text -partial class Class1 -{ - class Class2 - { - } -} -"; + var destinationDocumentText = """ + // Banner Text + partial class Class1 + { + class Class2 + { + } + } + + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText); @@ -1319,49 +1509,55 @@ await TestMoveTypeToNewFileAsync( public async Task TestTrailingCommentInContainer() { var code = -@"// Banner Text -using System; + """ + // Banner Text + using System; -class Class1 -{ - class [||]Class2 - { - } + class Class1 + { + class [||]Class2 + { + } - void Foo() - { - Console.WriteLine(); - } + void Foo() + { + Console.WriteLine(); + } - public int I() => 5; - // End of class document -} -"; - var codeAfterMove = @"// Banner Text -using System; + public int I() => 5; + // End of class document + } -partial class Class1 -{ + """; + var codeAfterMove = """ + // Banner Text + using System; - void Foo() - { - Console.WriteLine(); - } + partial class Class1 + { - public int I() => 5; - // End of class document -} -"; + void Foo() + { + Console.WriteLine(); + } + + public int I() => 5; + // End of class document + } + + """; var expectedDocumentName = "Class2.cs"; - var destinationDocumentText = @"// Banner Text -partial class Class1 -{ - class Class2 - { - } -} -"; + var destinationDocumentText = """ + // Banner Text + partial class Class1 + { + class Class2 + { + } + } + + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText); @@ -1371,46 +1567,52 @@ await TestMoveTypeToNewFileAsync( public async Task TestTrailingCommentInContainer2() { var code = -@"// Banner Text -using System; + """ + // Banner Text + using System; -class Class1 -{ - class [||]Class2 - { - } + class Class1 + { + class [||]Class2 + { + } - void Foo() - { - Console.WriteLine(); - } + void Foo() + { + Console.WriteLine(); + } - public int I() => 5; -} // End of class document -"; - var codeAfterMove = @"// Banner Text -using System; + public int I() => 5; + } // End of class document -partial class Class1 -{ + """; + var codeAfterMove = """ + // Banner Text + using System; - void Foo() - { - Console.WriteLine(); - } + partial class Class1 + { + + void Foo() + { + Console.WriteLine(); + } + + public int I() => 5; + } // End of class document - public int I() => 5; -} // End of class document -"; + """; var expectedDocumentName = "Class2.cs"; - var destinationDocumentText = @"// Banner Text -partial class Class1 -{ - class Class2 - { - } -}"; + var destinationDocumentText = """ + // Banner Text + partial class Class1 + { + class Class2 + { + } + } + """; await TestMoveTypeToNewFileAsync( code, codeAfterMove, expectedDocumentName, destinationDocumentText); @@ -1420,18 +1622,22 @@ await TestMoveTypeToNewFileAsync( public async Task MoveRecordToNewFilePreserveUsings() { var code = -@"using System; + """ + using System; -[||]record CacheContext(String Message); + [||]record CacheContext(String Message); -class Program { }"; + class Program { } + """; var codeAfterMove = @"class Program { }"; var expectedDocumentName = "CacheContext.cs"; - var destinationDocumentText = @"using System; + var destinationDocumentText = """ + using System; + + record CacheContext(String Message); -record CacheContext(String Message); -"; + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -1440,18 +1646,22 @@ record CacheContext(String Message); public async Task MoveClassToNewFilePreserveUsings_PrimaryConstructor() { var code = -@"using System; + """ + using System; -[||]class CacheContext(String Message); + [||]class CacheContext(String Message); -class Program { }"; + class Program { } + """; var codeAfterMove = @"class Program { }"; var expectedDocumentName = "CacheContext.cs"; - var destinationDocumentText = @"using System; + var destinationDocumentText = """ + using System; -class CacheContext(String Message); -"; + class CacheContext(String Message); + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -1460,18 +1670,22 @@ class CacheContext(String Message); public async Task MoveStructToNewFilePreserveUsings_PrimaryConstructor() { var code = -@"using System; + """ + using System; -[||]struct CacheContext(String Message); + [||]struct CacheContext(String Message); -class Program { }"; + class Program { } + """; var codeAfterMove = @"class Program { }"; var expectedDocumentName = "CacheContext.cs"; - var destinationDocumentText = @"using System; + var destinationDocumentText = """ + using System; + + struct CacheContext(String Message); -struct CacheContext(String Message); -"; + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -1480,18 +1694,24 @@ struct CacheContext(String Message); public async Task MoveInterfaceToNewFilePreserveUsings_PrimaryConstructor() { var code = -@"using System; + """ + using System; -[||]interface CacheContext(String Message); + [||]interface CacheContext(String Message); -class Program { }"; - var codeAfterMove = @"using System; + class Program { } + """; + var codeAfterMove = """ + using System; -class Program { }"; + class Program { } + """; var expectedDocumentName = "CacheContext.cs"; - var destinationDocumentText = @"interface CacheContext(String Message); -"; + var destinationDocumentText = """ + interface CacheContext(String Message); + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -1499,31 +1719,37 @@ class Program { }"; [WpfFact] public async Task MoveClassInTopLevelStatements() { - var code = @" -using ConsoleApp1; -using System; + var code = """ -var c = new C(); -Console.WriteLine(c.Hello); + using ConsoleApp1; + using System; -class [||]C -{ - public string Hello => ""Hello""; -}"; + var c = new C(); + Console.WriteLine(c.Hello); + + class [||]C + { + public string Hello => "Hello"; + } + """; + + var codeAfterMove = """ - var codeAfterMove = @" -using ConsoleApp1; -using System; + using ConsoleApp1; + using System; -var c = new C(); -Console.WriteLine(c.Hello); -"; + var c = new C(); + Console.WriteLine(c.Hello); + + """; var expectedDocumentName = "C.cs"; - var destinationDocumentText = @"class C -{ - public string Hello => ""Hello""; -}"; + var destinationDocumentText = """ + class C + { + public string Hello => "Hello"; + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -1531,13 +1757,15 @@ class [||]C [WpfFact] public async Task MissingInTopLevelStatementsOnly() { - var code = @" -using ConsoleApp1; -using System; + var code = """ -var c = new object(); -[||]Console.WriteLine(c.ToString()); -"; + using ConsoleApp1; + using System; + + var c = new object(); + [||]Console.WriteLine(c.ToString()); + + """; await TestMissingAsync(code); } @@ -1545,39 +1773,45 @@ public async Task MissingInTopLevelStatementsOnly() [WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/55544")] public async Task MoveInNamespace_WithAttributes1() { - var code = @" -using Sytem.Reflection; + var code = """ -[assembly: AssemblyCompany("")] -namespace N -{ - class A - { - } + using Sytem.Reflection; - class [||]B - { - } -}"; + [assembly: AssemblyCompany(")] + namespace N + { + class A + { + } + + class [||]B + { + } + } + """; - var codeAfterMove = @" -using Sytem.Reflection; + var codeAfterMove = """ -[assembly: AssemblyCompany("")] -namespace N -{ - class A - { - } -}"; + using Sytem.Reflection; + + [assembly: AssemblyCompany(")] + namespace N + { + class A + { + } + } + """; var expectedDocumentName = "B.cs"; - var destinationDocumentText = @"namespace N -{ - class B - { - } -}"; + var destinationDocumentText = """ + namespace N + { + class B + { + } + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -1585,41 +1819,47 @@ class B [WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/55544")] public async Task MoveInNamespace_WithAttributes2() { - var code = @" -using Sytem.Reflection; + var code = """ -[assembly: AssemblyCompany("")] -namespace N -{ - class A - { - } + using Sytem.Reflection; - [Test] - class [||]B - { - } -}"; + [assembly: AssemblyCompany(")] + namespace N + { + class A + { + } + + [Test] + class [||]B + { + } + } + """; - var codeAfterMove = @" -using Sytem.Reflection; + var codeAfterMove = """ -[assembly: AssemblyCompany("")] -namespace N -{ - class A - { - } -}"; + using Sytem.Reflection; + + [assembly: AssemblyCompany(")] + namespace N + { + class A + { + } + } + """; var expectedDocumentName = "B.cs"; - var destinationDocumentText = @"namespace N -{ - [Test] - class B - { - } -}"; + var destinationDocumentText = """ + namespace N + { + [Test] + class B + { + } + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -1627,36 +1867,42 @@ class B [WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/55544")] public async Task MoveInNamespace_WithAttributes3() { - var code = @" -namespace N -{ - class A - { - } + var code = """ - [Test] - class [||]B - { - } -}"; + namespace N + { + class A + { + } - var codeAfterMove = @" -namespace N -{ - class A - { - } -}"; + [Test] + class [||]B + { + } + } + """; + + var codeAfterMove = """ + + namespace N + { + class A + { + } + } + """; var expectedDocumentName = "B.cs"; - var destinationDocumentText = @" -namespace N -{ - [Test] - class B - { - } -}"; + var destinationDocumentText = """ + + namespace N + { + [Test] + class B + { + } + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -1664,27 +1910,33 @@ class B [WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/55544")] public async Task MoveTopLevel_WithAttributes1() { - var code = @" -[Test] -class [||]A -{ -} + var code = """ -class B -{ -}"; + [Test] + class [||]A + { + } - var codeAfterMove = @" -class B -{ -}"; + class B + { + } + """; + + var codeAfterMove = """ + + class B + { + } + """; var expectedDocumentName = "A.cs"; - var destinationDocumentText = @"[Test] -class A -{ -} -"; + var destinationDocumentText = """ + [Test] + class A + { + } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -1692,29 +1944,35 @@ class A [WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/55544")] public async Task MoveTopLevel_WithAttributes2() { - var code = @" -[Test] -class [||]A -{ -} + var code = """ -[Test] -class B -{ -}"; + [Test] + class [||]A + { + } - var codeAfterMove = @" -[Test] -class B -{ -}"; + [Test] + class B + { + } + """; + + var codeAfterMove = """ + + [Test] + class B + { + } + """; var expectedDocumentName = "A.cs"; - var destinationDocumentText = @"[Test] -class A -{ -} -"; + var destinationDocumentText = """ + [Test] + class A + { + } + + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } @@ -1727,25 +1985,31 @@ class A [InlineData("record")] public async Task MoveNestedTypeFromInterface(string memberType) { - var code = $@" -interface I -{{ - {memberType} [||]Member - {{ - }} -}}"; - var codeAfterMove = @" -partial interface I -{ -}"; + var code = $$""" + + interface I + { + {{memberType}} [||]Member + { + } + } + """; + var codeAfterMove = """ + + partial interface I + { + } + """; var expectedDocumentName = "Member.cs"; - var destinationDocumentText = $@" -partial interface I -{{ - {memberType} Member - {{ - }} -}}"; + var destinationDocumentText = $$""" + + partial interface I + { + {{memberType}} Member + { + } + } + """; await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText); } }