Formater rewrite.

src/Draco.Compiler.Benchmarks/E2eBenchmarks.cs

@@ -11,8 +11,7 @@ public class E2eBenchmarks : FolderBenchmarkBase
 {
     private MemoryStream peStream = null!;
 
-    public E2eBenchmarks()
-        : base("e2e")
+    public E2eBenchmarks() : base("e2e")
     {
     }
 

src/Draco.Compiler.Cli/Program.cs

@@ -179,7 +179,7 @@ private static void FormatCommand(FileInfo input, FileInfo? output)
     {
         var syntaxTree = GetSyntaxTrees(input).First();
         using var outputStream = OpenOutputOrStdout(output);
-        new StreamWriter(outputStream).Write(syntaxTree.Format().ToString());
+        new StreamWriter(outputStream).Write(syntaxTree.Format());
     }
 
     private static ImmutableArray<SyntaxTree> GetSyntaxTrees(params FileInfo[] input)

src/Draco.Compiler.Tests/Syntax/ParseTreeFormatterTests.cs

@@ -1,11 +1,12 @@
 using Draco.Compiler.Api.Syntax;
+using Xunit.Abstractions;
 
 namespace Draco.Compiler.Tests.Syntax;
 
-public sealed class SyntaxTreeFormatterTests
+public sealed class SyntaxTreeFormatterTests(ITestOutputHelper logger)
 {
     [Fact]
-    public void TestFormatting()
+    public void SomeCodeSampleShouldBeFormattedCorrectly()
     {
         var input = """"
              func  main  ( )  {
@@ -17,6 +18,7 @@ func  main  ( )  {
              val singleLineString =   ""  ;
                     var   multilineString   =  #"""
                     something
+                    test
                 """# ;
                 val  y
                 =   4-2
@@ -58,6 +60,7 @@ func main() {
                 val singleLineString = "";
                 var multilineString = #"""
                         something
+                        test
                     """#;
                 val y = 4 - 2 mod 4 + 3;
                 while (true) {
@@ -89,12 +92,12 @@ func main() {
 
             """";
 
-        var actual = SyntaxTree.Parse(input).Format().ToString();
+        var actual = SyntaxTree.Parse(input).Format();
         Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
     }
 
     [Fact]
-    public void TestFormattingInlineMethod()
+    public void InlineMethodShouldBeFormattedCorrectly()
     {
         var input = """
             import System.Console;
@@ -109,14 +112,243 @@ func main() {
         var expected = """
             import System.Console;
 
-            func max(a:int32, b:int32): int32 = if (a > b) a else b;
+            func max(a: int32, b: int32): int32 = if (a > b) a else b;
 
             func main() {
                 WriteLine(max(12, 34));
             }
 
             """;
-        var actual = SyntaxTree.Parse(input).Format().ToString();
+        var actual = SyntaxTree.Parse(input).Format();
+        Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
+    }
+
+    [Fact]
+    public void SimpleExpressionShouldBeFormattedCorrectly()
+    {
+        var input = """
+            func aLongMethodName() = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10;
+            """;
+        var expected = """
+            func aLongMethodName() = 1
+                                   + 2
+                                   + 3
+                                   + 4
+                                   + 5
+                                   + 6
+                                   + 7
+                                   + 8
+                                   + 9
+                                   + 10;
+
+            """;
+        var actual = SyntaxTree.Parse(input).Format(new Internal.Syntax.Formatting.FormatterSettings()
+        {
+            LineWidth = 60
+        });
+        Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
+    }
+
+    [Fact]
+    public void ExpressionInMultiLineStringDoesNotChange()
+    {
+        var input = """"
+            func main() {
+                val someMultiLineString = """
+                    the result:\{1 + 2 + 3 + 4 + 5
+                    + 6 + 7 + 8 + 9 + 10}
+                    """;
+            }
+
+            """";
+        var actual = SyntaxTree.Parse(input).Format(new Internal.Syntax.Formatting.FormatterSettings()
+        {
+            LineWidth = 50
+        });
+        Assert.Equal(input, actual, ignoreLineEndingDifferences: true);
+    }
+
+    [Fact]
+    public void MultiReturnInMultiLineStringArePreserved()
+    {
+        var input = """"
+            func main() {
+                val someMultiLineString = """
+                    bla bla
+
+
+                    bla bla
+
+                    """;
+            }
+
+            """";
+        var actual = SyntaxTree.Parse(input).Format();
+        Assert.Equal(input, actual, ignoreLineEndingDifferences: true);
+    }
+
+    [Fact]
+    public void MultiReturnInMultiLineStringArePreserved2()
+    {
+        var input = """"
+            func main() {
+                val someMultiLineString = """
+                    bla bla
+
+
+                    bla bla
+
+
+                    """;
+            }
+
+            """";
+        var actual = SyntaxTree.Parse(input).Format();
+        Assert.Equal(input, actual, ignoreLineEndingDifferences: true);
+    }
+
+    [Fact]
+    public void IfElseChainFormatsCorrectly()
+    {
+        var input = """"
+            func main() {
+                if (false)
+                expr1
+                else if (false)
+                    expr2
+            else if (false) expr3
+                else    expr4
+            }
+            """";
+        var expected = """"
+            func main() {
+                if (false) expr1
+                else if (false) expr2
+                else if (false) expr3
+                else expr4
+            }
+
+            """";
+        var actual = SyntaxTree.Parse(input).Format();
+        Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
+    }
+
+    [Fact]
+    public void TooLongArgsFoldsInsteadOfExpr()
+    {
+        var input = """
+            func main(lots: Of, arguments: That, will: Be, fold: But) = nnot + this;
+            """;
+        var expected = """
+            func main(
+                lots: Of,
+                arguments: That,
+                will: Be,
+                fold: But) = nnot + this;
+
+            """;
+        var actual = SyntaxTree.Parse(input).Format(new Internal.Syntax.Formatting.FormatterSettings()
+        {
+            LineWidth = 60
+        });
         Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
     }
+
+    [Fact]
+    public void NoLineReturnInSingleLineString()
+    {
+        var input = """"
+            func main() {
+                val value = "Value: \{if (input < value) "low" else "high"}";
+            }
+
+            """";
+        var actual = SyntaxTree.Parse(input).Format(new Internal.Syntax.Formatting.FormatterSettings()
+        {
+            LineWidth = 10
+        });
+        Assert.Equal(input, actual, ignoreLineEndingDifferences: true);
+    }
+
+    [Fact]
+    public void Sample1()
+    {
+        var input = """"
+            import System;
+            import System.Console;
+
+            func main() {
+                val value = Random.Shared.Next(1, 101);
+                while (true) {
+                    Write("Guess a number (1-100): ");
+                    val input = Convert.ToInt32(ReadLine());
+                    if (input == value) goto break;
+                    WriteLine("Incorrect. Too \{if (input < value) "low" else "high"}");
+                }
+                WriteLine("You guessed it!");
+            }
+
+            """";
+        var actual = SyntaxTree.Parse(input).Format(new Internal.Syntax.Formatting.FormatterSettings()
+        {
+            LineWidth = 50
+        });
+        Assert.Equal(input, actual, ignoreLineEndingDifferences: true);
+    }
+
+    [Fact]
+    public void CursedSample()
+    {
+        var input = """"
+            //test
+            func //test
+                main
+                // another
+                // foobar
+                () {
+                var
+                    // test
+                    opponent = "R";
+                var me = "P";
+                if // heh
+                    (me == opponent) return println("draw");
+                if (
+                    // heh
+                    me == "R") {
+                    println(if (opponent == "P") "lose" else "win");
+                }
+                else if ( // heh
+                    me == "P") {
+                    println(if (opponent == "R") "win" else "lose");
+                }
+                else if (me == "S") {
+                    println(if (opponent == "P") "win" else "lose");
+                }
+            } // oh hello
+            // oops.
+
+            """";
+        var actual = SyntaxTree.Parse(input).Format();
+        logger.WriteLine(actual);
+        Assert.Equal(input, actual, ignoreLineEndingDifferences: true);
+    }
+
+    [Fact]
+    public void CursedSample2()
+    {
+        var input = """"
+            func foo(a: int32) {
+                if ({
+                    var x = a * 2;
+                    x > 50
+                }) {
+                    WriteLine("ohno");
+                }
+            }
+
+            """";
+        var actual = SyntaxTree.Parse(input).Format();
+        logger.WriteLine(actual);
+        Assert.Equal(input, actual, ignoreLineEndingDifferences: true);
+    }
 }

src/Draco.Compiler/Api/Syntax/ElseClauseSyntax.cs

@@ -0,0 +1,11 @@
+namespace Draco.Compiler.Api.Syntax;
+
+public partial class ElseClauseSyntax
+{
+    /// <summary>
+    /// Returns <see langword="true"/> when the else clause is followed by an if expression.
+    /// </summary>
+    public bool IsElseIf => this.Expression is StatementExpressionSyntax statementExpression
+                            && statementExpression.Statement is ExpressionStatementSyntax expressionStatement
+                            && expressionStatement.Expression is IfExpressionSyntax;
+}

src/Draco.Compiler/Api/Syntax/SeparatedSyntaxList.cs

@@ -4,7 +4,6 @@
 using System.Linq;
 using System.Reflection;
 using System.Threading;
-using Draco.Compiler.Internal;
 
 namespace Draco.Compiler.Api.Syntax;
 

src/Draco.Compiler/Api/Syntax/StringPartSyntax.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Linq;
+
+namespace Draco.Compiler.Api.Syntax;
+public partial class StringPartSyntax
+{
+    /// <summary>
+    /// <see langword="true"/> when this <see cref="StringPartSyntax"/> is a <see cref="SyntaxToken"/> with <see cref="TokenKind.StringNewline"/>.
+    /// </summary>
+    public bool IsNewLine => this.Children.Count() == 1 && this.Children.SingleOrDefault() is SyntaxToken and { Kind: TokenKind.StringNewline };
+}

src/Draco.Compiler/Api/Syntax/SyntaxList.cs

@@ -4,7 +4,6 @@
 using System.Linq;
 using System.Reflection;
 using System.Threading;
-using Draco.Compiler.Internal;
 
 namespace Draco.Compiler.Api.Syntax;
 

src/Draco.Compiler/Api/Syntax/SyntaxTree.cs

@@ -4,7 +4,6 @@
 using System.Linq;
 using System.Threading;
 using Draco.Compiler.Api.Diagnostics;
-using Draco.Compiler.Internal;
 using Draco.Compiler.Internal.Syntax;
 using Draco.Compiler.Internal.Syntax.Formatting;
 using Draco.Compiler.Internal.Syntax.Rewriting;
@@ -157,7 +156,7 @@ public ImmutableArray<TextEdit> SyntaxTreeDiff(SyntaxTree other) =>
     /// Syntactically formats this <see cref="SyntaxTree"/>.
     /// </summary>
     /// <returns>The formatted tree.</returns>
-    public SyntaxTree Format() => Formatter.Format(this);
+    public string Format(FormatterSettings? settings = null) => DracoFormatter.Format(this, settings);
 
     /// <summary>
     /// The internal root of the tree.

src/Draco.Compiler/Draco.Compiler.csproj

@@ -13,6 +13,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\Draco.FormatterEngine\Draco.FormatterEngine.csproj" />
     <ProjectReference Include="..\Draco.SourceGeneration\Draco.SourceGeneration.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="False" />
   </ItemGroup>
 

src/Draco.Compiler/Internal/Binding/Binder_Lookup.cs

@@ -3,7 +3,6 @@
 using System.Collections.Immutable;
 using System.Linq;
 using Draco.Compiler.Api.Syntax;
-using Draco.Compiler.Internal.BoundTree;
 using Draco.Compiler.Internal.Diagnostics;
 using Draco.Compiler.Internal.Solver;
 using Draco.Compiler.Internal.Solver.Tasks;

src/Draco.Compiler/Internal/Diagnostics/ConcurrentDiagnosticBag.cs

@@ -1,7 +1,5 @@
-using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
 using Draco.Compiler.Api.Diagnostics;
 
 namespace Draco.Compiler.Internal.Diagnostics;