Quoter

src/Draco.Compiler.DevHost/Program.cs

@@ -7,12 +7,26 @@
 using Draco.Compiler.Api;
 using Draco.Compiler.Api.Scripting;
 using Draco.Compiler.Api.Syntax;
+using Draco.Compiler.Api.Syntax.Quoting;
 using static Basic.Reference.Assemblies.Net80;
 
 namespace Draco.Compiler.DevHost;
 
 internal class Program
 {
+    private enum CliQuoteMode
+    {
+        file,
+        decl,
+        stmt,
+        expr,
+    }
+
+    private enum CliOutputLanguage
+    {
+        cs,
+    }
+
     private static IEnumerable<MetadataReference> BclReferences => ReferenceInfos.All
         .Select(r => MetadataReference.FromPeStream(new MemoryStream(r.ImageBytes)));
 
@@ -27,6 +41,10 @@ private static RootCommand ConfigureCommands()
         var referencesOption = new Option<FileInfo[]>(["-r", "--reference"], Array.Empty<FileInfo>, "Specifies additional assembly references to use when compiling");
         var filesArgument = new Argument<FileInfo[]>("source files", Array.Empty<FileInfo>, "Specifies draco source files that should be compiled");
         var rootModuleOption = new Option<DirectoryInfo?>(["-m", "--root-module"], () => null, "Specifies the root module folder of the compiled files");
+        var quoteModeOption = new Option<CliQuoteMode>(["-m", "--quote-mode"], () => CliQuoteMode.file, "Specifies the kind of syntactic element to quote");
+        var outputLanguageOption = new Option<CliOutputLanguage>(["-l", "--language"], () => CliOutputLanguage.cs, "Specifies the language to output the quoted code as");
+        var prettyPrintOption = new Option<bool>(["-p", "--pretty-print"], () => false, "Whether to append whitespace to the output code");
+        var staticImportOption = new Option<bool>(["-s", "--require-static-import"], () => false, "Whether to require the SyntaxFactory class to be imported statically in the output code");
 
         // Compile
 
@@ -88,14 +106,27 @@ private static RootCommand ConfigureCommands()
         };
         formatCommand.SetHandler(FormatCommand, fileArgument, optionalOutputOption);
 
+        // Quoting
+
+        var quoteCommand = new Command("quote", "Generates a string of code in an output language which produces syntax nodes equivalent to the input code")
+        {
+            fileArgument,
+            quoteModeOption,
+            outputLanguageOption,
+            prettyPrintOption,
+            staticImportOption,
+        };
+        quoteCommand.SetHandler(QuoteCommand, fileArgument, quoteModeOption, outputLanguageOption, prettyPrintOption, staticImportOption);
+
         return new RootCommand("CLI for the Draco compiler")
         {
             compileCommand,
             runCommand,
             irCommand,
             symbolsCommand,
             declarationsCommand,
-            formatCommand
+            formatCommand,
+            quoteCommand,
         };
     }
 
@@ -179,6 +210,34 @@ private static void FormatCommand(FileInfo input, FileInfo? output)
         new StreamWriter(outputStream).Write(syntaxTree.Format().ToString());
     }
 
+    private static void QuoteCommand(
+        FileInfo input,
+        CliQuoteMode mode,
+        CliOutputLanguage outputLanguage,
+        bool prettyPrint,
+        bool staticImport)
+    {
+        var sourceText = SourceText.FromFile(input.FullName);
+        var quotedText = SyntaxQuoter.Quote(
+            sourceText,
+            mode switch
+            {
+                CliQuoteMode.file => QuoteMode.File,
+                CliQuoteMode.decl => QuoteMode.Declaration,
+                CliQuoteMode.stmt => QuoteMode.Statement,
+                CliQuoteMode.expr => QuoteMode.Expression,
+                _ => throw new ArgumentOutOfRangeException(nameof(mode))
+            },
+            outputLanguage switch
+            {
+                CliOutputLanguage.cs => OutputLanguage.CSharp,
+                _ => throw new ArgumentOutOfRangeException(nameof(outputLanguage))
+            },
+            prettyPrint,
+            staticImport);
+        Console.WriteLine(quotedText);
+    }
+
     private static ImmutableArray<SyntaxTree> GetSyntaxTrees(params FileInfo[] input)
     {
         var result = ImmutableArray.CreateBuilder<SyntaxTree>();

src/Draco.Compiler/Api/Syntax/Quoting/CSharpQuoterTemplate.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Text;
+using Draco.Compiler.Internal.Utilities;
+
+namespace Draco.Compiler.Api.Syntax.Quoting;
+
+/// <summary>
+/// Outputs quoted code as C# code.
+/// </summary>
+/// <param name="builder">The string builder for the template to append text to.</param>
+/// <param name="prettyPrint">Whether to append whitespace.</param>
+/// <param name="staticImport">Whether to append <c>SyntaxFactory.</c> before properties and function calls.</param>
+internal sealed class CSharpQuoterTemplate(StringBuilder builder, bool prettyPrint, bool staticImport)
+{
+    private int indentLevel = 0;
+
+    /// <summary>
+    /// Generates C# code from a <see cref="QuoteExpression"/>.
+    /// </summary>
+    /// <param name="expr">The expression to generate code from.</param>
+    /// <param name="prettyPrint">Whether to append whitespace.</param>
+    /// <param name="staticImport">Whether to append <c>SyntaxFactory.</c> before properties and function calls.</param>
+    /// <returns></returns>
+    public static string Generate(QuoteExpression expr, bool prettyPrint, bool staticImport)
+    {
+        var builder = new StringBuilder();
+        var template = new CSharpQuoterTemplate(builder, prettyPrint, staticImport);
+        template.AppendExpr(expr);
+        return builder.ToString();
+    }
+
+    private void AppendExpr(QuoteExpression expr)
+    {
+        switch (expr)
+        {
+        case QuoteFunctionCall call:
+            this.AppendFunctionCall(call);
+            break;
+
+        case QuoteProperty(var property):
+            this.TryAppendSyntaxFactory();
+            builder.Append(property);
+            break;
+
+        case QuoteList list:
+            this.AppendList(list);
+            break;
+
+        case QuoteNull:
+            builder.Append("null");
+            break;
+
+        case QuoteTokenKind(var kind):
+            builder.Append("TokenKind.");
+            builder.Append(kind.ToString());
+            break;
+
+        case QuoteInteger(var value):
+            builder.Append(value);
+            break;
+
+        case QuoteFloat(var value):
+            builder.Append(value);
+            break;
+
+        case QuoteBoolean(var value):
+            builder.Append(value ? "true" : "false");
+            break;
+
+        case QuoteCharacter(var value):
+            builder.Append('\'');
+            // Need this for escape characters.
+            builder.Append(StringUtils.Unescape(value.ToString()));
+            builder.Append('\'');
+            break;
+
+        case QuoteString(var value):
+            builder.Append('"');
+            builder.Append(StringUtils.Unescape(value));
+            builder.Append('"');
+            break;
+
+        default:
+            throw new ArgumentOutOfRangeException(nameof(expr));
+        }
+    }
+
+    private void AppendFunctionCall(QuoteFunctionCall call)
+    {
+        var (function, typeArgs, args) = call;
+
+        this.TryAppendSyntaxFactory();
+        builder.Append(function);
+
+        if (typeArgs is not [])
+        {
+            builder.Append('<');
+            for (var i = 0; i < typeArgs.Length; i++)
+            {
+                builder.Append(typeArgs[i]);
+
+                if (i < typeArgs.Length - 1) builder.Append(", ");
+            }
+            builder.Append('>');
+        }
+
+        // Place function calls with a single simple expression as its argument on a single line.
+        if (call.Arguments is [var singleArg] && IsSimple(singleArg))
+        {
+            builder.Append('(');
+            this.AppendExpr(singleArg);
+            builder.Append(')');
+
+            return;
+        }
+
+        builder.Append('(');
+        this.indentLevel += 1;
+        for (var i = 0; i < args.Length; i++)
+        {
+            this.TryAppendNewLine();
+            this.TryAppendIndentation();
+
+            this.AppendExpr(args[i]);
+
+            if (i < args.Length - 1) builder.Append(prettyPrint ? "," : ", ");
+        }
+        this.indentLevel -= 1;
+        builder.Append(')');
+    }
+
+    private void AppendList(QuoteList list)
+    {
+        var values = list.Values;
+
+        builder.Append('[');
+        this.indentLevel += 1;
+        for (var i = 0; i < values.Length; i++)
+        {
+            this.TryAppendNewLine();
+            this.TryAppendIndentation();
+
+            this.AppendExpr(values[i]);
+
+            if (i < values.Length - 1) builder.Append(prettyPrint ? "," : ", ");
+        }
+        this.indentLevel -= 1;
+        builder.Append(']');
+    }
+
+    private void TryAppendSyntaxFactory()
+    {
+        if (!staticImport) builder.Append("SyntaxFactory.");
+    }
+
+    private void TryAppendIndentation()
+    {
+        // Todo: perhaps parameterize indentation size
+        if (prettyPrint) builder.Append(' ', this.indentLevel * 2);
+    }
+
+    private void TryAppendNewLine()
+    {
+        if (prettyPrint) builder.Append(Environment.NewLine);
+    }
+
+    /// <summary>
+    /// Checks whether an expression is "simple" and can be placed on the same line as a function call when passed as an argument.
+    /// </summary>
+    /// <param name="expr">The expression to check.</param>
+    /// <returns>Whether the expression is simple.</returns>
+    private static bool IsSimple(QuoteExpression expr) => expr
+        is QuoteProperty
+        or QuoteNull
+        or QuoteTokenKind
+        or QuoteInteger
+        or QuoteFloat
+        or QuoteBoolean
+        or QuoteCharacter
+        or QuoteString;
+}

src/Draco.Compiler/Api/Syntax/Quoting/QuoteExpressionModel.cs

@@ -0,0 +1,79 @@
+using System.Collections.Immutable;
+
+namespace Draco.Compiler.Api.Syntax.Quoting;
+
+/// <summary>
+/// An expression generated by the quoter.
+/// </summary>
+internal abstract record QuoteExpression;
+
+/// <summary>
+/// A function call quote expression.
+/// </summary>
+/// <param name="Function">The name of the function in <see cref="SyntaxFactory"/>.</param>
+/// <param name="TypeArguments">The type arguments to the function.</param>
+/// <param name="Arguments">The arguments to the function.</param>
+internal sealed record QuoteFunctionCall(
+    string Function,
+    ImmutableArray<string> TypeArguments,
+    ImmutableArray<QuoteExpression> Arguments)
+    : QuoteExpression
+{
+    public QuoteFunctionCall(string function, ImmutableArray<QuoteExpression> arguments)
+        : this(function, [], arguments)
+    {
+    }
+}
+
+/// <summary>
+/// A property access quote expression.
+/// </summary>
+/// <param name="Property">The name of the property in <see cref="SyntaxFactory"/>.</param>
+internal sealed record QuoteProperty(string Property) : QuoteExpression;
+
+/// <summary>
+/// A list quote expression.
+/// </summary>
+/// <param name="Values">The values in the list.</param>
+internal sealed record QuoteList(ImmutableArray<QuoteExpression> Values) : QuoteExpression;
+
+/// <summary>
+/// A null quote expression.
+/// </summary>
+internal sealed record QuoteNull : QuoteExpression;
+
+/// <summary>
+/// A token kind quote expression.
+/// </summary>
+/// <param name="Value">The token kind.</param>
+internal sealed record QuoteTokenKind(TokenKind Value) : QuoteExpression;
+
+/// <summary>
+/// An integer quote expression.
+/// </summary>
+/// <param name="Value">The integer value.</param>
+internal sealed record QuoteInteger(int Value) : QuoteExpression;
+
+/// <summary>
+/// A float quote expression.
+/// </summary>
+/// <param name="Value">The float value.</param>
+internal sealed record QuoteFloat(float Value) : QuoteExpression;
+
+/// <summary>
+/// A boolean quote expression.
+/// </summary>
+/// <param name="Value">The boolean value.</param>
+internal sealed record QuoteBoolean(bool Value) : QuoteExpression;
+
+/// <summary>
+/// A character quote expression.
+/// </summary>
+/// <param name="Value">The character value.</param>
+internal sealed record QuoteCharacter(char Value) : QuoteExpression;
+
+/// <summary>
+/// A string quote expression.
+/// </summary>
+/// <param name="Value">The string value.</param>
+internal sealed record QuoteString(string Value) : QuoteExpression;