Complete 'file' support for SyntaxGenerator

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));
 

src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs

@@ -2284,6 +2284,84 @@ public void TestWithModifiers_AllowedModifiers()
                 Generator.GetModifiers(Generator.WithModifiers(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration), allModifiers)));
         }
 
+        [Fact]
+        public void TestAddPublicToStaticConstructor()
+        {
+            var ctor = Generator.ConstructorDeclaration("C", modifiers: DeclarationModifiers.Static);
+            VerifySyntax<ConstructorDeclarationSyntax>(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<ConstructorDeclarationSyntax>(publicCtor, @"static C()
+{
+}");
+        }
+
+        [Fact]
+        public void TestAddStaticToPublicConstructor()
+        {
+            var ctor = Generator.ConstructorDeclaration("C", accessibility: Accessibility.Public);
+            VerifySyntax<ConstructorDeclarationSyntax>(ctor, @"public C()
+{
+}");
+
+            var staticCtor = Generator.WithModifiers(ctor, DeclarationModifiers.Static);
+            VerifySyntax<ConstructorDeclarationSyntax>(staticCtor, @"public static C()
+{
+}");
+        }
+
+        [Fact]
+        public void TestAddAbstractToFileClass()
+        {
+            var fileClass = (ClassDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration("file class C { }");
+            var fileAbstractClass = Generator.WithModifiers(fileClass, Generator.GetModifiers(fileClass).WithIsAbstract(true));
+            VerifySyntax<ClassDeclarationSyntax>(fileAbstractClass, @"file 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).
+            // 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<ClassDeclarationSyntax>(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));
+            VerifySyntax<ClassDeclarationSyntax>(fileAbstractClass, @"file 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).
+            // 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<ClassDeclarationSyntax>(filePublicClass, @"public file class C
+{
+}");
+        }
+
         [Fact]
         public void TestGetType()
         {

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,
                 };