From 3d5004290e95912b247eb2a161926add1f02e996 Mon Sep 17 00:00:00 2001 From: Youssef1313 Date: Wed, 6 Jul 2022 08:05:47 +0200 Subject: [PATCH 1/7] Add bad tests --- .../CodeGeneration/SyntaxGeneratorTests.cs | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs index 1829328657951..0ee7bafeeed20 100644 --- a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs +++ b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs @@ -2284,6 +2284,54 @@ public void TestWithModifiers_AllowedModifiers() Generator.GetModifiers(Generator.WithModifiers(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration), allModifiers))); } + [Fact] + public void TestAddAbstractToFileClass() + { + var fileClass = (ClassDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration("file class C { }"); + var fileAbstractClass = Generator.WithModifiers(fileClass, Generator.GetModifiers(fileClass).WithIsAbstract(true)); + // bad output. It will be fixed in a later commit. + // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). + VerifySyntax(fileAbstractClass, @"abstract class C +{ +}"); + } + + [Fact] + public void TestAddPublicToFileClass() + { + var fileClass = (ClassDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration("file class C { }"); + var filePublicClass = Generator.WithAccessibility(fileClass, Accessibility.Public); + // bad output. It will be fixed in a later commit. + // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). + VerifySyntax(filePublicClass, @"file class C +{ +}"); + } + + [Fact] + public void TestAddFileModifierToAbstractClass() + { + var abstractClass = (ClassDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration("abstract class C { }"); + var fileAbstractClass = Generator.WithModifiers(abstractClass, Generator.GetModifiers(abstractClass).WithIsFile(true)); + // bad output. It will be fixed in a later commit. + // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). + VerifySyntax(fileAbstractClass, @"abstract class C +{ +}"); + } + + [Fact] + public void TestAddFileModifierToPublicClass() + { + var publicClass = (ClassDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration("public class C { }"); + var filePublicClass = Generator.WithModifiers(publicClass, Generator.GetModifiers(publicClass).WithIsFile(true)); + // bad output. It will be fixed in a later commit. + // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). + VerifySyntax(filePublicClass, @"public class C +{ +}"); + } + [Fact] public void TestGetType() { From 4318870205327d31310a5df63847e0f73e712ba0 Mon Sep 17 00:00:00 2001 From: Youssef1313 Date: Wed, 6 Jul 2022 08:24:32 +0200 Subject: [PATCH 2/7] Step 1 in supporting file in SyntaxGenerator --- .../Portable/CodeGeneration/CSharpSyntaxGenerator.cs | 3 +++ .../CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs | 11 ++++------- .../Services/SyntaxFacts/CSharpAccessibilityFacts.cs | 1 + 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs index 3ba8fffee3e30..3cd5b058439d3 100644 --- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs +++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs @@ -1628,6 +1628,9 @@ private static SyntaxTokenList AsModifierList(Accessibility accessibility, Decla break; } + if (modifiers.IsFile) + list.Add(SyntaxFactory.Token(SyntaxKind.FileKeyword)); + if (modifiers.IsAbstract) list.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); diff --git a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs index 0ee7bafeeed20..a4f00d166b2a2 100644 --- a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs +++ b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs @@ -2289,9 +2289,7 @@ public void TestAddAbstractToFileClass() { var fileClass = (ClassDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration("file class C { }"); var fileAbstractClass = Generator.WithModifiers(fileClass, Generator.GetModifiers(fileClass).WithIsAbstract(true)); - // bad output. It will be fixed in a later commit. - // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). - VerifySyntax(fileAbstractClass, @"abstract class C + VerifySyntax(fileAbstractClass, @"file abstract class C { }"); } @@ -2313,9 +2311,7 @@ public void TestAddFileModifierToAbstractClass() { var abstractClass = (ClassDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration("abstract class C { }"); var fileAbstractClass = Generator.WithModifiers(abstractClass, Generator.GetModifiers(abstractClass).WithIsFile(true)); - // bad output. It will be fixed in a later commit. - // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). - VerifySyntax(fileAbstractClass, @"abstract class C + VerifySyntax(fileAbstractClass, @"file abstract class C { }"); } @@ -2327,7 +2323,8 @@ public void TestAddFileModifierToPublicClass() var filePublicClass = Generator.WithModifiers(publicClass, Generator.GetModifiers(publicClass).WithIsFile(true)); // bad output. It will be fixed in a later commit. // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). - VerifySyntax(filePublicClass, @"public class C + // note, behavior changed here in this commit since we supported file, but the most correct behavior is to eliminate public completely. + VerifySyntax(filePublicClass, @"public file class C { }"); } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs index 0f19e230090f4..0a0aac9cf40fc 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs @@ -141,6 +141,7 @@ public static void GetAccessibilityAndModifiers(SyntaxTokenList modifierList, ou SyntaxKind.RefKeyword => DeclarationModifiers.Ref, SyntaxKind.VolatileKeyword => DeclarationModifiers.Volatile, SyntaxKind.ExternKeyword => DeclarationModifiers.Extern, + SyntaxKind.FileKeyword => DeclarationModifiers.File, _ => DeclarationModifiers.None, }; From ad72767d20dfdda51a9be26ae9f6ac907756e0fe Mon Sep 17 00:00:00 2001 From: Youssef1313 Date: Wed, 6 Jul 2022 08:38:18 +0200 Subject: [PATCH 3/7] Expected behavior is unclear --- .../CodeGeneration/SyntaxGeneratorTests.cs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs index a4f00d166b2a2..47162b2322908 100644 --- a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs +++ b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs @@ -2284,6 +2284,22 @@ public void TestWithModifiers_AllowedModifiers() Generator.GetModifiers(Generator.WithModifiers(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration), allModifiers))); } + [Fact] + public void TestAddPublicToStaticConstructor() + { + var ctor = Generator.ConstructorDeclaration("C", parameters: null, accessibility: Accessibility.NotApplicable, modifiers: DeclarationModifiers.Static); + VerifySyntax(ctor, @"static C() +{ +}"); + + var publicCtor = Generator.WithAccessibility(ctor, Accessibility.Public); + // Yes, it's correct that static constructors cannot have accessibility, but why not static is "replaced" with public? + // The same issue exists for file types that cannot have accessibility. Should attempting to make them public do "nothing"? + VerifySyntax(publicCtor, @"static C() +{ +}"); + } + [Fact] public void TestAddAbstractToFileClass() { @@ -2301,6 +2317,8 @@ public void TestAddPublicToFileClass() var filePublicClass = Generator.WithAccessibility(fileClass, Accessibility.Public); // bad output. It will be fixed in a later commit. // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). + // What 's the expected behavior is unclear given an existing behavior for static constructors demonstrated in this commit (the new test is passing) + // The current behavior might be correct if we'll follow the static constructors behavior. VerifySyntax(filePublicClass, @"file class C { }"); @@ -2324,6 +2342,7 @@ public void TestAddFileModifierToPublicClass() // bad output. It will be fixed in a later commit. // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). // note, behavior changed here in this commit since we supported file, but the most correct behavior is to eliminate public completely. + // note 2, the correct behavior here is actually not very clear given the constructor case and the opposite case of this. VerifySyntax(filePublicClass, @"public file class C { }"); From 7a19e41400c5cffb3762614d9a0fac06c892039b Mon Sep 17 00:00:00 2001 From: Youssef1313 Date: Wed, 6 Jul 2022 09:03:11 +0200 Subject: [PATCH 4/7] Add test showing behavior for adding static to public ctor --- .../CodeGeneration/SyntaxGeneratorTests.cs | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs index 47162b2322908..eb7f10b3f4693 100644 --- a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs +++ b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs @@ -2287,7 +2287,7 @@ public void TestWithModifiers_AllowedModifiers() [Fact] public void TestAddPublicToStaticConstructor() { - var ctor = Generator.ConstructorDeclaration("C", parameters: null, accessibility: Accessibility.NotApplicable, modifiers: DeclarationModifiers.Static); + var ctor = Generator.ConstructorDeclaration("C", modifiers: DeclarationModifiers.Static); VerifySyntax(ctor, @"static C() { }"); @@ -2300,6 +2300,20 @@ public void TestAddPublicToStaticConstructor() }"); } + [Fact] + public void TestAddStaticToPublicConstructor() + { + var ctor = Generator.ConstructorDeclaration("C", accessibility: Accessibility.Public); + VerifySyntax(ctor, @"public C() +{ +}"); + + var staticCtor = Generator.WithModifiers(ctor, DeclarationModifiers.Static); + VerifySyntax(staticCtor, @"public static C() +{ +}"); + } + [Fact] public void TestAddAbstractToFileClass() { From 084b0e7e558b55326c99a2edf4cb68e7a105ed02 Mon Sep 17 00:00:00 2001 From: Youssef1313 Date: Wed, 6 Jul 2022 19:55:09 +0200 Subject: [PATCH 5/7] Step 2 - drop static (for constructors) and file modifiers when adding accessibility --- .../CodeGeneration/CSharpSyntaxGenerator.cs | 21 ++++++++++++++++++- .../CodeGeneration/SyntaxGeneratorTests.cs | 10 ++------- .../SyntaxFacts/CSharpAccessibilityFacts.cs | 6 +++--- .../SyntaxFacts/IAccessibilityFacts.cs | 7 ++++++- .../VisualBasicAccessibilityFacts.vb | 2 +- .../VisualBasicSyntaxGenerator.vb | 2 +- 6 files changed, 33 insertions(+), 15 deletions(-) diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs index 3cd5b058439d3..ddeb6502fe10e 100644 --- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs +++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs @@ -1348,7 +1348,12 @@ public override SyntaxNode InsertMembers(SyntaxNode declaration, int index, IEnu }; private static bool CanHaveAccessibility(SyntaxNode declaration) - => CSharpAccessibilityFacts.Instance.CanHaveAccessibility(declaration); + // For certain declarations, the answer of CanHaveAccessibility depends on the modifiers. + // For example, static constructors cannot have accessibility, but constructors in general can. + // The same applies to file-local declarations (e.g, "file class C { }"). + // For such declarations, we want to return true. This is because we can be explicitly asked to put accessibility. + // In such cases, we'll drop the modifier that prevents us from having accessibility. + => CSharpAccessibilityFacts.Instance.CanHaveAccessibility(declaration, ignoreDeclarationModifiers: true); public override Accessibility GetAccessibility(SyntaxNode declaration) => CSharpAccessibilityFacts.Instance.GetAccessibility(declaration); @@ -1368,6 +1373,20 @@ public override SyntaxNode WithAccessibility(SyntaxNode declaration, Accessibili { var tokens = GetModifierTokens(d); GetAccessibilityAndModifiers(tokens, out _, out var modifiers, out _); + if (modifiers.IsFile && accessibility != Accessibility.NotApplicable) + { + // If user wants to set accessibility for a file-local declaration, we remove file. + // Otherwise, code will be in error: + // error CS9052: File type '{0}' cannot use accessibility modifiers. + modifiers = modifiers.WithIsFile(false); + } + + if (modifiers.IsStatic && declaration.IsKind(SyntaxKind.ConstructorDeclaration) && accessibility != Accessibility.NotApplicable) + { + // If user wants to add accessibility for a static constructor, we remove static modifier + modifiers = modifiers.WithIsStatic(false); + } + var newTokens = Merge(tokens, AsModifierList(accessibility, modifiers)); return SetModifierTokens(d, newTokens); }); diff --git a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs index eb7f10b3f4693..ae3f53c297a62 100644 --- a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs +++ b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs @@ -2293,9 +2293,7 @@ public void TestAddPublicToStaticConstructor() }"); var publicCtor = Generator.WithAccessibility(ctor, Accessibility.Public); - // Yes, it's correct that static constructors cannot have accessibility, but why not static is "replaced" with public? - // The same issue exists for file types that cannot have accessibility. Should attempting to make them public do "nothing"? - VerifySyntax(publicCtor, @"static C() + VerifySyntax(publicCtor, @"public C() { }"); } @@ -2329,11 +2327,7 @@ public void TestAddPublicToFileClass() { var fileClass = (ClassDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration("file class C { }"); var filePublicClass = Generator.WithAccessibility(fileClass, Accessibility.Public); - // bad output. It will be fixed in a later commit. - // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). - // What 's the expected behavior is unclear given an existing behavior for static constructors demonstrated in this commit (the new test is passing) - // The current behavior might be correct if we'll follow the static constructors behavior. - VerifySyntax(filePublicClass, @"file class C + VerifySyntax(filePublicClass, @"public class C { }"); } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs index 0a0aac9cf40fc..08fa2b0c4a2ba 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs @@ -23,7 +23,7 @@ private CSharpAccessibilityFacts() { } - public bool CanHaveAccessibility(SyntaxNode declaration) + public bool CanHaveAccessibility(SyntaxNode declaration, bool ignoreDeclarationModifiers = false) { switch (declaration.Kind()) { @@ -34,7 +34,7 @@ public bool CanHaveAccessibility(SyntaxNode declaration) case SyntaxKind.InterfaceDeclaration: case SyntaxKind.EnumDeclaration: case SyntaxKind.DelegateDeclaration: - return !((MemberDeclarationSyntax)declaration).Modifiers.Any(SyntaxKind.FileKeyword); + return ignoreDeclarationModifiers || !((MemberDeclarationSyntax)declaration).Modifiers.Any(SyntaxKind.FileKeyword); case SyntaxKind.FieldDeclaration: case SyntaxKind.EventFieldDeclaration: @@ -52,7 +52,7 @@ public bool CanHaveAccessibility(SyntaxNode declaration) case SyntaxKind.ConstructorDeclaration: // Static constructor can't have accessibility - return !((ConstructorDeclarationSyntax)declaration).Modifiers.Any(SyntaxKind.StaticKeyword); + return ignoreDeclarationModifiers || !((ConstructorDeclarationSyntax)declaration).Modifiers.Any(SyntaxKind.StaticKeyword); case SyntaxKind.PropertyDeclaration: return ((PropertyDeclarationSyntax)declaration).ExplicitInterfaceSpecifier == null; diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/IAccessibilityFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/IAccessibilityFacts.cs index c0b3e350484b9..1f54c840e2a98 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/IAccessibilityFacts.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/IAccessibilityFacts.cs @@ -6,7 +6,12 @@ namespace Microsoft.CodeAnalysis.LanguageServices { internal interface IAccessibilityFacts { - bool CanHaveAccessibility(SyntaxNode declaration); + /// + /// Returns whether a given declaration can have accessibility or not. + /// + /// The declaration node to check + /// A flag that indicates whether to consider modifiers on the given declaration that blocks adding accessibility. + bool CanHaveAccessibility(SyntaxNode declaration, bool ignoreDeclarationModifiers = false); Accessibility GetAccessibility(SyntaxNode declaration); } } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicAccessibilityFacts.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicAccessibilityFacts.vb index cee652c1b0da4..5ff79eb177b2a 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicAccessibilityFacts.vb +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicAccessibilityFacts.vb @@ -20,7 +20,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices Private Sub New() End Sub - Public Function CanHaveAccessibility(declaration As SyntaxNode) As Boolean Implements IAccessibilityFacts.CanHaveAccessibility + Public Function CanHaveAccessibility(declaration As SyntaxNode, Optional ignoreDeclarationModifiers As Boolean = False) As Boolean Implements IAccessibilityFacts.CanHaveAccessibility Select Case declaration.Kind Case SyntaxKind.ClassBlock, SyntaxKind.ClassStatement, diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb index 2be866568a94b..c4ca32fea8aa5 100644 --- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb +++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb @@ -2608,7 +2608,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration End Function Private Shared Function CanHaveAccessibility(declaration As SyntaxNode) As Boolean - Return VisualBasicAccessibilityFacts.Instance.CanHaveAccessibility(declaration) + Return VisualBasicAccessibilityFacts.Instance.CanHaveAccessibility(declaration, ignoreDeclarationModifiers:=True) End Function Private Function WithAccessibilityInternal(declaration As SyntaxNode, accessibility As Accessibility) As SyntaxNode From 92b76b1446e4732fd0893cc366ab3f7cc860df1d Mon Sep 17 00:00:00 2001 From: Youssef1313 Date: Wed, 6 Jul 2022 20:12:55 +0200 Subject: [PATCH 6/7] Step 3 - drop accessibility when adding static to constructor, or when adding file --- .../Portable/CodeGeneration/CSharpSyntaxGenerator.cs | 9 +++++++++ .../CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs | 4 ++-- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs index ddeb6502fe10e..aacfcd25d420d 100644 --- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs +++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs @@ -1591,6 +1591,15 @@ private SyntaxNode WithModifiersInternal(SyntaxNode declaration, DeclarationModi { var tokens = GetModifierTokens(d); GetAccessibilityAndModifiers(tokens, out var accessibility, out var tmp, out _); + if (accessibility != Accessibility.NotApplicable) + { + if (modifiers.IsFile || + (modifiers.IsStatic && declaration.IsKind(SyntaxKind.ConstructorDeclaration))) + { + // We remove the accessibility if the modifiers don't allow it. + accessibility = Accessibility.NotApplicable; + } + } var newTokens = Merge(tokens, AsModifierList(accessibility, modifiers)); return SetModifierTokens(d, newTokens); }); diff --git a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs index ae3f53c297a62..6f18f408894df 100644 --- a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs +++ b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs @@ -2307,7 +2307,7 @@ public void TestAddStaticToPublicConstructor() }"); var staticCtor = Generator.WithModifiers(ctor, DeclarationModifiers.Static); - VerifySyntax(staticCtor, @"public static C() + VerifySyntax(staticCtor, @"static C() { }"); } @@ -2351,7 +2351,7 @@ public void TestAddFileModifierToPublicClass() // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). // note, behavior changed here in this commit since we supported file, but the most correct behavior is to eliminate public completely. // note 2, the correct behavior here is actually not very clear given the constructor case and the opposite case of this. - VerifySyntax(filePublicClass, @"public file class C + VerifySyntax(filePublicClass, @"file class C { }"); } From 6d77068c3a437f417d7658cf503a61bc5b51fc22 Mon Sep 17 00:00:00 2001 From: Youssef1313 Date: Wed, 6 Jul 2022 20:33:12 +0200 Subject: [PATCH 7/7] Remove outdated comment --- .../CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs index 6f18f408894df..83856f7093c3a 100644 --- a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs +++ b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs @@ -2347,10 +2347,6 @@ public void TestAddFileModifierToPublicClass() { var publicClass = (ClassDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration("public class C { }"); var filePublicClass = Generator.WithModifiers(publicClass, Generator.GetModifiers(publicClass).WithIsFile(true)); - // bad output. It will be fixed in a later commit. - // This commit just demonstrates the *current* behavior (test is passing currently, while it shouldn't). - // note, behavior changed here in this commit since we supported file, but the most correct behavior is to eliminate public completely. - // note 2, the correct behavior here is actually not very clear given the constructor case and the opposite case of this. VerifySyntax(filePublicClass, @"file class C { }");