Formater rewrite.

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,13 @@
 using Draco.Compiler.Api.Syntax;
+using Draco.Compiler.Internal.Syntax.Formatting;
+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 +19,7 @@ func  main  ( )  {
              val singleLineString =   ""  ;
                     var   multilineString   =  #"""
                     something
+                    test
                 """# ;
                 val  y
                 =   4-2
@@ -58,6 +61,7 @@ func main() {
                 val singleLineString = "";
                 var multilineString = #"""
                         something
+                        test
                     """#;
                 val y = 4 - 2 mod 4 + 3;
                 while (true) {
@@ -89,12 +93,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 +113,263 @@ 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);
+    }
+
+    [Fact]
+    public void DontMergeTokens()
+    {
+        var input = """"
+            func foo() {
+                var x
+                + =
+                1;
+            }
+
+            """";
+
+        var actual = SyntaxTree.Parse(input).Format(new FormatterSettings()
+        {
+            SpaceAroundBinaryOperators = false
+        });
+        logger.WriteLine(actual);
+        Assert.Equal(input, actual, ignoreLineEndingDifferences: true);
+    }
 }

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

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Draco.Compiler.Api.Syntax;
+
+namespace Draco.Compiler.Tests.Syntax;
+public class SyntaxHelpersTests
+{
+
+    [Fact]
+    public void TestIfElseIfExpression()
+    {
+        var res = SyntaxTree.Parse("func main() { var a = if (true) 1 else if (false) 2 else 3 }");
+        var statement = (((res.Root as CompilationUnitSyntax)!.Declarations.Single() as FunctionDeclarationSyntax)!.Body as BlockFunctionBodySyntax)!.Statements.Single() as DeclarationStatementSyntax;
+        var variableDeclaration = statement!.Declaration as VariableDeclarationSyntax;
+        var ifExpression = variableDeclaration!.Value!.Value as IfExpressionSyntax;
+        Assert.True(ifExpression!.Else!.IsElseIf);
+    }
+}

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

@@ -0,0 +1,13 @@
+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 IfExpressionSyntax
+                        || this.Expression is StatementExpressionSyntax statementExpression
+                            && statementExpression.Statement is ExpressionStatementSyntax expressionStatement
+                            && expressionStatement.Expression is IfExpressionSyntax;
+}

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/SyntaxFacts.cs

@@ -1,4 +1,6 @@
 using System.Diagnostics;
+using Draco.Compiler.Internal.Syntax.Formatting;
+using Draco.Compiler.Internal.Syntax;
 
 namespace Draco.Compiler.Api.Syntax;
 
@@ -161,4 +163,12 @@ internal static string ComputeCutoff(Internal.Syntax.StringExpressionSyntax str)
         Debug.Assert(str.CloseQuotes.LeadingTrivia[1].Kind == TriviaKind.Whitespace);
         return str.CloseQuotes.LeadingTrivia[1].Text;
     }
+
+    public static bool WillTokenMerges(string leftToken, string rightToken)
+    {
+        var lexer = new Lexer(SourceReader.From(leftToken + rightToken), default);
+        lexer.Lex();
+        var secondToken = lexer.Lex();
+        return secondToken.Kind == TokenKind.EndOfInput;
+    }
 }

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

@@ -156,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.