Add support for file-scoped namespaces, #113 (#115)

paulirwin · web-flow · commit ac597a55acf3 · 2024-02-22T19:39:43.000-07:00
This change surfaced some annoying whitespace behavior with Roslyn's
NormalizeWhitespace method, so this adds some leading/trailing newlines
in places after NormalizeWhitespace is called to help prettify the
output.
diff --git a/JavaToCSharp/CommentsHelper.cs b/JavaToCSharp/CommentsHelper.cs
@@ -448,7 +448,7 @@ static SyntaxNode InsertEmptyLineBeforeComment(SyntaxNode node)
                     }
 
                     node = statement.InsertTriviaBefore(leading[index],
-                        Enumerable.Repeat(SyntaxFactory.CarriageReturnLineFeed, 1));
+                        Enumerable.Repeat(Whitespace.NewLine, 1));
                 }
             }
 
diff --git a/JavaToCSharp/Declarations/ConstructorDeclarationVisitor.cs b/JavaToCSharp/Declarations/ConstructorDeclarationVisitor.cs
@@ -3,7 +3,6 @@
 using com.github.javaparser.ast.stmt;
 using com.github.javaparser.ast.type;
 using JavaToCSharp.Statements;
-using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
@@ -24,8 +23,7 @@ public class ConstructorDeclarationVisitor : BodyDeclarationVisitor<ConstructorD
             return null;
         }
 
-        var ctorSyntax = SyntaxFactory.ConstructorDeclaration(identifier)
-                                      .WithLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed);
+        var ctorSyntax = SyntaxFactory.ConstructorDeclaration(identifier).WithLeadingNewLines();
 
         var mods = ctorDecl.getModifiers().ToModifierKeywordSet();
 
diff --git a/JavaToCSharp/Extensions.cs b/JavaToCSharp/Extensions.cs
@@ -1,6 +1,7 @@
 ﻿using System.Diagnostics.CodeAnalysis;
 using java.util;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using JavaAst = com.github.javaparser.ast;
 
@@ -77,4 +78,12 @@ public static T FromRequiredOptional<T>(this Optional optional)
     public static ISet<JavaAst.Modifier.Keyword> ToModifierKeywordSet(this JavaAst.NodeList nodeList)
         => nodeList.ToList<JavaAst.Modifier>()?.Select(i => i.getKeyword()).ToHashSet()
            ?? new HashSet<JavaAst.Modifier.Keyword>();
+
+    public static TSyntax WithLeadingNewLines<TSyntax>(this TSyntax syntax, int count = 1)
+        where TSyntax : SyntaxNode
+        => syntax.WithLeadingTrivia(Enumerable.Repeat(Whitespace.NewLine, count));
+
+    public static TSyntax WithTrailingNewLines<TSyntax>(this TSyntax syntax, int count = 1)
+        where TSyntax : SyntaxNode
+        => syntax.WithTrailingTrivia(Enumerable.Repeat(Whitespace.NewLine, count));
 }
diff --git a/JavaToCSharp/JavaConversionOptions.cs b/JavaToCSharp/JavaConversionOptions.cs
@@ -31,6 +31,8 @@ public class JavaConversionOptions
 
     public bool IncludeComments { get; set; } = true;
 
+    public bool UseFileScopedNamespaces { get; set; }
+
     public ConversionState ConversionState { get; set; }
 
     public JavaConversionOptions AddPackageReplacement(string pattern, string replacement, RegexOptions options = RegexOptions.None)
diff --git a/JavaToCSharp/JavaToCSharpConverter.cs b/JavaToCSharp/JavaToCSharpConverter.cs
@@ -54,7 +54,7 @@ public static class JavaToCSharpConverter
         var package = result.getPackageDeclaration().FromOptional<PackageDeclaration>();
 
         var rootMembers = new List<MemberDeclarationSyntax>();
-        NamespaceDeclarationSyntax? namespaceSyntax = null;
+        NameSyntax? namespaceNameSyntax = null;
 
         if (options.IncludeNamespace)
         {
@@ -72,7 +72,7 @@ public static class JavaToCSharpConverter
 
             packageName = TypeHelper.Capitalize(packageName);
 
-            namespaceSyntax = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(packageName));
+            namespaceNameSyntax = SyntaxFactory.ParseName(packageName);
         }
 
         foreach (var type in types)
@@ -82,57 +82,55 @@ public static class JavaToCSharpConverter
                 if (classOrIntType.isInterface())
                 {
                     var interfaceSyntax = ClassOrInterfaceDeclarationVisitor.VisitInterfaceDeclaration(context, classOrIntType);
-
-                    if (namespaceSyntax != null)
-                    {
-                        namespaceSyntax = namespaceSyntax.AddMembers(interfaceSyntax);
-                    }
-                    else
-                    {
-                        rootMembers.Add(interfaceSyntax);
-                    }
+                    rootMembers.Add(interfaceSyntax.NormalizeWhitespace().WithTrailingNewLines());
                 }
                 else
                 {
                     var classSyntax = ClassOrInterfaceDeclarationVisitor.VisitClassDeclaration(context, classOrIntType);
-
-                    if (namespaceSyntax != null)
-                    {
-                        namespaceSyntax = namespaceSyntax.AddMembers(classSyntax);
-                    }
-                    else
-                    {
-                        rootMembers.Add(classSyntax);
-                    }
+                    rootMembers.Add(classSyntax.NormalizeWhitespace().WithTrailingNewLines());
                 }
             }
             else if (type is EnumDeclaration enumType)
             {
-                var classSyntax = EnumDeclarationVisitor.VisitEnumDeclaration(context, enumType);
+                var enumSyntax = EnumDeclarationVisitor.VisitEnumDeclaration(context, enumType);
+                rootMembers.Add(enumSyntax.NormalizeWhitespace().WithTrailingNewLines());
+            }
+        }
 
-                if (namespaceSyntax != null)
-                {
-                    namespaceSyntax = namespaceSyntax.AddMembers(classSyntax);
-                }
-                else
-                {
-                    rootMembers.Add(classSyntax);
-                }
+        if (rootMembers.Count > 1)
+        {
+            for (int i = 1; i < rootMembers.Count; i++)
+            {
+                rootMembers[i] = rootMembers[i].WithLeadingNewLines();
             }
         }
 
-        if (namespaceSyntax != null)
+        if (namespaceNameSyntax != null)
         {
-            rootMembers.Add(namespaceSyntax);
+            if (options.UseFileScopedNamespaces && rootMembers.Count > 0)
+            {
+                rootMembers[0] = rootMembers[0].WithLeadingNewLines();
+            }
+
+            MemberDeclarationSyntax namespaceSyntax =
+                options.UseFileScopedNamespaces
+                ? SyntaxFactory.FileScopedNamespaceDeclaration(namespaceNameSyntax)
+                    .NormalizeWhitespace()
+                    .WithTrailingNewLines()
+                    .WithMembers(SyntaxFactory.List(rootMembers))
+                : SyntaxFactory.NamespaceDeclaration(namespaceNameSyntax)
+                    .WithMembers(SyntaxFactory.List(rootMembers))
+                    .NormalizeWhitespace();
+
+            rootMembers = [namespaceSyntax];
         }
 
         var root = SyntaxFactory.CompilationUnit(
                 externs: [],
-                usings: SyntaxFactory.List(UsingsHelper.GetUsings(context, imports, options, rootMembers, namespaceSyntax)),
+                usings: SyntaxFactory.List(UsingsHelper.GetUsings(context, imports, options, namespaceNameSyntax)),
                 attributeLists: [],
                 members: SyntaxFactory.List(rootMembers)
-            )
-            .NormalizeWhitespace();
+            );
 
         root = root.WithPackageFileComments(context, result, package);
 
diff --git a/JavaToCSharp/UsingsHelper.cs b/JavaToCSharp/UsingsHelper.cs
@@ -1,4 +1,5 @@
 using com.github.javaparser.ast;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
@@ -9,16 +10,15 @@ public static class UsingsHelper
     public static IEnumerable<UsingDirectiveSyntax> GetUsings(ConversionContext context,
         IEnumerable<ImportDeclaration> imports,
         JavaConversionOptions? options,
-        IEnumerable<MemberDeclarationSyntax> rootMembers,
-        NamespaceDeclarationSyntax? namespaceSyntax)
+        NameSyntax? namespaceNameSyntax)
     {
         var usings = new List<UsingDirectiveSyntax>();
 
         foreach (var import in imports)
         {
             // The import directive in Java will import a specific class.
             string importName = import.getNameAsString();
-            var lastPartStartIndex = importName.LastIndexOf(".", StringComparison.Ordinal);
+            var lastPartStartIndex = importName.LastIndexOf('.');
             var importNameWithoutClassName = lastPartStartIndex == -1 ?
                                                  importName :
                                                  importName[..lastPartStartIndex];
@@ -30,29 +30,38 @@ public static IEnumerable<UsingDirectiveSyntax> GetUsings(ConversionContext cont
                 usingSyntax = CommentsHelper.AddUsingComments(usingSyntax, import);
             }
 
-            usings.Add(usingSyntax);
+            usings.Add(usingSyntax.NormalizeWhitespace().WithTrailingNewLines());
         }
 
         if (options?.IncludeUsings == true)
         {
             usings.AddRange(options.Usings
                 .Where(x => !string.IsNullOrWhiteSpace(x))
-                .Select(ns => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(ns))));
+                .Select(ns => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(ns)).NormalizeWhitespace().WithTrailingNewLines()));
         }
 
-        if (namespaceSyntax != null)
+        if (namespaceNameSyntax != null)
         {
             foreach (var staticUsing in options?.StaticUsingEnumNames ?? [])
             {
                 var usingSyntax = SyntaxFactory
-                    .UsingDirective(SyntaxFactory.ParseName($"{namespaceSyntax.Name}.{staticUsing}"))
-                    .WithStaticKeyword(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
+                    .UsingDirective(SyntaxFactory.ParseName($"{namespaceNameSyntax}.{staticUsing}"))
+                    .WithStaticKeyword(SyntaxFactory.Token(SyntaxKind.StaticKeyword))
+                    .NormalizeWhitespace()
+                    .WithTrailingNewLines();
 
                 usings.Add(usingSyntax);
             }
         }
 
-        return usings.Distinct(new UsingDirectiveSyntaxComparer()).ToList();
+        usings = usings.Distinct(new UsingDirectiveSyntaxComparer()).ToList();
+
+        if (usings.Count > 0)
+        {
+            usings[^1] = usings[^1].WithTrailingNewLines(2);
+        }
+
+        return usings;
     }
 }
 
diff --git a/JavaToCSharp/Whitespace.cs b/JavaToCSharp/Whitespace.cs
@@ -0,0 +1,11 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace JavaToCSharp;
+
+public static class Whitespace
+{
+    public static SyntaxTrivia NewLine => Environment.NewLine == "\r\n"
+        ? SyntaxFactory.CarriageReturnLineFeed
+        : SyntaxFactory.LineFeed;
+}
diff --git a/JavaToCSharpCli/Program.cs b/JavaToCSharpCli/Program.cs
@@ -48,6 +48,11 @@ public class Program
         description: "Convert System.out calls to Console",
         getDefaultValue: () => false);
 
+    private static readonly Option<bool> _fileScopedNamespacesOption = new(
+        name: "--file-scoped-namespaces",
+        description: "Use file-scoped namespaces in C# output",
+        getDefaultValue: () => false);
+
     private static readonly Option<bool> _clearDefaultUsingsOption = new(
         name: "--clear-usings",
         description: "Remove all default usings provided by this app",
@@ -84,6 +89,7 @@ public static async Task Main(string[] args)
         rootCommand.AddGlobalOption(_startInterfaceNamesWithIOption);
         rootCommand.AddGlobalOption(_commentUnrecognizedCodeOption);
         rootCommand.AddGlobalOption(_systemOutToConsoleOption);
+        rootCommand.AddGlobalOption(_fileScopedNamespacesOption);
         rootCommand.AddGlobalOption(_clearDefaultUsingsOption);
         rootCommand.AddGlobalOption(_addUsingsOption);
 
@@ -131,7 +137,8 @@ private static JavaConversionOptions GetJavaConversionOptions(InvocationContext
             ConvertSystemOutToConsole = context.ParseResult.GetValueForOption(_systemOutToConsoleOption),
             StartInterfaceNamesWithI = context.ParseResult.GetValueForOption(_startInterfaceNamesWithIOption),
             UseDebugAssertForAsserts = context.ParseResult.GetValueForOption(_useDebugAssertOption),
-            UseUnrecognizedCodeToComment = context.ParseResult.GetValueForOption(_commentUnrecognizedCodeOption)
+            UseUnrecognizedCodeToComment = context.ParseResult.GetValueForOption(_commentUnrecognizedCodeOption),
+            UseFileScopedNamespaces = context.ParseResult.GetValueForOption(_fileScopedNamespacesOption),
         };
 
         if (context.ParseResult.GetValueForOption(_clearDefaultUsingsOption))
diff --git a/JavaToCSharpGui/App.config b/JavaToCSharpGui/App.config
@@ -28,6 +28,9 @@
             <setting name="Usings" serializeAs="String">
                 <value>System;System.Collections.Generic;System.Collections.ObjectModel;System.Linq;System.Text</value>
             </setting>
+            <setting name="UseFileScopedNamespaces" serializeAs="String">
+                <value>False</value>
+            </setting>
         </JavaToCSharpGui.Properties.Settings>
     </userSettings>
 </configuration>
diff --git a/JavaToCSharpGui/CurrentOptions.cs b/JavaToCSharpGui/CurrentOptions.cs
@@ -13,6 +13,7 @@ static CurrentOptions()
         Options.UseDebugAssertForAsserts = Settings.Default.UseDebugAssertPreference;
         Options.UseUnrecognizedCodeToComment = Settings.Default.UseUnrecognizedCodeToComment;
         Options.ConvertSystemOutToConsole = Settings.Default.ConvertSystemOutToConsole;
+        Options.UseFileScopedNamespaces = Settings.Default.UseFileScopedNamespaces;
 
         Options.SetUsings(Settings.Default.Usings.Split(';'));
     }
@@ -27,6 +28,7 @@ public static void Persist()
         Settings.Default.UseDebugAssertPreference = Options.UseDebugAssertForAsserts;
         Settings.Default.UseUnrecognizedCodeToComment = Options.UseUnrecognizedCodeToComment;
         Settings.Default.ConvertSystemOutToConsole = Options.ConvertSystemOutToConsole;
+        Settings.Default.UseFileScopedNamespaces = Options.UseFileScopedNamespaces;
         Settings.Default.Usings = string.Join(";", Options.Usings);
 
         Settings.Default.Save();
diff --git a/JavaToCSharpGui/Properties/Settings.Designer.cs b/JavaToCSharpGui/Properties/Settings.Designer.cs
diff --git a/JavaToCSharpGui/Properties/Settings.settings b/JavaToCSharpGui/Properties/Settings.settings
@@ -23,5 +23,8 @@
     <Setting Name="Usings" Type="System.String" Scope="User">
       <Value Profile="(Default)">System;System.Collections.Generic;System.Collections.ObjectModel;System.Linq;System.Text</Value>
     </Setting>
+    <Setting Name="UseFileScopedNamespaces" Type="System.Boolean" Scope="User">
+      <Value Profile="(Default)">False</Value>
+    </Setting>
   </Settings>
 </SettingsFile>
diff --git a/JavaToCSharpGui/ViewModels/SettingsWindowViewModel.cs b/JavaToCSharpGui/ViewModels/SettingsWindowViewModel.cs
@@ -24,6 +24,8 @@ public partial class SettingsWindowViewModel : ViewModelBase
 
     [ObservableProperty] private bool _convertSystemOutToConsole = CurrentOptions.Options.ConvertSystemOutToConsole;
 
+    [ObservableProperty] private bool _useFileScopedNamespaces = CurrentOptions.Options.UseFileScopedNamespaces;
+
     public event EventHandler? CloseRequested;
 
     [RelayCommand]
@@ -51,6 +53,7 @@ private void Save()
         CurrentOptions.Options.UseDebugAssertForAsserts = UseDebugAssertForAsserts;
         CurrentOptions.Options.UseUnrecognizedCodeToComment = UnrecognizedCodeToComment;
         CurrentOptions.Options.ConvertSystemOutToConsole = ConvertSystemOutToConsole;
+        CurrentOptions.Options.UseFileScopedNamespaces = UseFileScopedNamespaces;
 
         CurrentOptions.Options.SetUsings(Usings);
 
diff --git a/JavaToCSharpGui/Views/SettingsWindow.axaml b/JavaToCSharpGui/Views/SettingsWindow.axaml
@@ -38,6 +38,10 @@
                               IsChecked="{CompiledBinding IncludeNamespace}">
                         Include namespace in output
                     </CheckBox>
+                    <CheckBox Margin="5" Name="UseFileScopedNamespaces"
+                              IsChecked="{CompiledBinding UseFileScopedNamespaces}">
+                        Use file-scoped namespaces
+                    </CheckBox>
                     <CheckBox Margin="5" Name="IncludeComments"
                               IsChecked="{CompiledBinding IncludeComments}">
                         Include comments in output

Original file line number	Diff line number	Diff line change
`@@ -448,7 +448,7 @@ static SyntaxNode InsertEmptyLineBeforeComment(SyntaxNode node)`
`448`	`448`	`}`
`449`	`449`
`450`	`450`	`node = statement.InsertTriviaBefore(leading[index],`
`451`		`- Enumerable.Repeat(SyntaxFactory.CarriageReturnLineFeed, 1));`
	`451`	`+ Enumerable.Repeat(Whitespace.NewLine, 1));`
`452`	`452`	`}`
`453`	`453`	`}`
`454`	`454`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using com.github.javaparser.ast;`
	`2`	`+using Microsoft.CodeAnalysis;`
`2`	`3`	`using Microsoft.CodeAnalysis.CSharp;`
`3`	`4`	`using Microsoft.CodeAnalysis.CSharp.Syntax;`
`4`	`5`
`@@ -9,16 +10,15 @@ public static class UsingsHelper`
`9`	`10`	`public static IEnumerable<UsingDirectiveSyntax> GetUsings(ConversionContext context,`
`10`	`11`	`IEnumerable<ImportDeclaration> imports,`
`11`	`12`	`JavaConversionOptions? options,`
`12`		`- IEnumerable<MemberDeclarationSyntax> rootMembers,`
`13`		`- NamespaceDeclarationSyntax? namespaceSyntax)`
	`13`	`+ NameSyntax? namespaceNameSyntax)`
`14`	`14`	`{`
`15`	`15`	`var usings = new List<UsingDirectiveSyntax>();`
`16`	`16`
`17`	`17`	`foreach (var import in imports)`
`18`	`18`	`{`
`19`	`19`	`// The import directive in Java will import a specific class.`
`20`	`20`	`string importName = import.getNameAsString();`
`21`		`- var lastPartStartIndex = importName.LastIndexOf(".", StringComparison.Ordinal);`
	`21`	`+ var lastPartStartIndex = importName.LastIndexOf('.');`
`22`	`22`	`var importNameWithoutClassName = lastPartStartIndex == -1 ?`
`23`	`23`	`importName :`
`24`	`24`	`importName[..lastPartStartIndex];`
`@@ -30,29 +30,38 @@ public static IEnumerable<UsingDirectiveSyntax> GetUsings(ConversionContext cont`
`30`	`30`	`usingSyntax = CommentsHelper.AddUsingComments(usingSyntax, import);`
`31`	`31`	`}`
`32`	`32`
`33`		`- usings.Add(usingSyntax);`
	`33`	`+ usings.Add(usingSyntax.NormalizeWhitespace().WithTrailingNewLines());`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`if (options?.IncludeUsings == true)`
`37`	`37`	`{`
`38`	`38`	`usings.AddRange(options.Usings`
`39`	`39`	`.Where(x => !string.IsNullOrWhiteSpace(x))`
`40`		`- .Select(ns => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(ns))));`
	`40`	`+ .Select(ns => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(ns)).NormalizeWhitespace().WithTrailingNewLines()));`
`41`	`41`	`}`
`42`	`42`
`43`		`- if (namespaceSyntax != null)`
	`43`	`+ if (namespaceNameSyntax != null)`
`44`	`44`	`{`
`45`	`45`	`foreach (var staticUsing in options?.StaticUsingEnumNames ?? [])`
`46`	`46`	`{`
`47`	`47`	`var usingSyntax = SyntaxFactory`
`48`		`- .UsingDirective(SyntaxFactory.ParseName($"{namespaceSyntax.Name}.{staticUsing}"))`
`49`		`- .WithStaticKeyword(SyntaxFactory.Token(SyntaxKind.StaticKeyword));`
	`48`	`+ .UsingDirective(SyntaxFactory.ParseName($"{namespaceNameSyntax}.{staticUsing}"))`
	`49`	`+ .WithStaticKeyword(SyntaxFactory.Token(SyntaxKind.StaticKeyword))`
	`50`	`+ .NormalizeWhitespace()`
	`51`	`+ .WithTrailingNewLines();`
`50`	`52`
`51`	`53`	`usings.Add(usingSyntax);`
`52`	`54`	`}`
`53`	`55`	`}`
`54`	`56`
`55`		`- return usings.Distinct(new UsingDirectiveSyntaxComparer()).ToList();`
	`57`	`+ usings = usings.Distinct(new UsingDirectiveSyntaxComparer()).ToList();`
	`58`	`+`
	`59`	`+ if (usings.Count > 0)`
	`60`	`+ {`
	`61`	`+ usings[^1] = usings[^1].WithTrailingNewLines(2);`
	`62`	`+ }`
	`63`	`+`
	`64`	`+ return usings;`
`56`	`65`	`}`
`57`	`66`	`}`
`58`	`67`