Basics of #if/else if/else/end conditionals

Author: nblumhardt

src/Serilog.Expressions/System.Diagnostics.CodeAnalysis/NotNullAttributes.cs renamed to src/Serilog.Expressions/Compatibility/NotNullAttributes.cs

@@ -129,7 +129,7 @@ enum ExpressionToken
         [Token(Category = "keyword", Example = "ci")]
         CI,
 
-        // Template syntax only
+        // Template syntax
 
         [Token(Description = "text")]
         Text,
@@ -140,7 +140,13 @@ enum ExpressionToken
         [Token(Example = "}}")]
         DoubleRBrace,
 
+        [Token(Example = "{#")]
+        LBraceHash,
+        
         [Token(Description = "format specifier")]
         Format,
+        
+        [Token(Category = "keyword", Example = "end")]
+        End,
     }
 }

src/Serilog.Expressions/Expressions/Parsing/ExpressionToken.cs

@@ -23,6 +23,7 @@ class ExpressionTokenizer : Tokenizer<ExpressionToken>
             new ExpressionKeyword("if", ExpressionToken.If),
             new ExpressionKeyword("then", ExpressionToken.Then),
             new ExpressionKeyword("else", ExpressionToken.Else),
+            new ExpressionKeyword("end", ExpressionToken.End),
             new ExpressionKeyword("ci", ExpressionToken.CI)
         };
 

src/Serilog.Expressions/Expressions/Parsing/ExpressionTokenizer.cs

@@ -0,0 +1,19 @@
+using System;
+using Serilog.Expressions.Ast;
+
+namespace Serilog.Templates.Ast
+{
+    class Conditional : Template
+    {
+        public Expression Condition { get; }
+        public Template Consequent { get; }
+        public Template? Alternative { get; }
+
+        public Conditional(Expression condition, Template consequent, Template? alternative)
+        {
+            Condition = condition ?? throw new ArgumentNullException(nameof(condition));
+            Consequent = consequent ?? throw new ArgumentNullException(nameof(consequent));
+            Alternative = alternative;
+        }
+    }
+}

src/Serilog.Expressions/Templates/Ast/Conditional.cs

@@ -0,0 +1,29 @@
+using System;
+using System.IO;
+using Serilog.Events;
+using Serilog.Expressions;
+
+namespace Serilog.Templates.Compilation
+{
+    class CompiledConditional : CompiledTemplate
+    {
+        readonly CompiledExpression _condition;
+        readonly CompiledTemplate _consequent;
+        readonly CompiledTemplate? _alternative;
+
+        public CompiledConditional(CompiledExpression condition, CompiledTemplate consequent, CompiledTemplate? alternative)
+        {
+            _condition = condition ?? throw new ArgumentNullException(nameof(condition));
+            _consequent = consequent ?? throw new ArgumentNullException(nameof(consequent));
+            _alternative = alternative;
+        }
+
+        public override void Evaluate(LogEvent logEvent, TextWriter output, IFormatProvider? formatProvider)
+        {
+            if (ExpressionResult.IsTrue(_condition.Invoke(logEvent)))
+                _consequent.Evaluate(logEvent, output, formatProvider);
+            else
+                _alternative?.Evaluate(logEvent, output, formatProvider);
+        }
+    }
+}

src/Serilog.Expressions/Templates/Compilation/CompiledConditional.cs

@@ -17,6 +17,10 @@ public static CompiledTemplate Compile(Template template, NameResolver nameResol
                 FormattedExpression expression => new CompiledFormattedExpression(
                     ExpressionCompiler.Compile(expression.Expression, nameResolver), expression.Format, expression.Alignment),
                 TemplateBlock block => new CompiledTemplateBlock(block.Elements.Select(e => Compile(e, nameResolver)).ToArray()),
+                Conditional conditional => new CompiledConditional(
+                    ExpressionCompiler.Compile(conditional.Condition, nameResolver),
+                    Compile(conditional.Consequent, nameResolver),
+                    conditional.Alternative == null ? null : Compile(conditional.Consequent, nameResolver)),
                 _ => throw new NotSupportedException()
             };
         }

src/Serilog.Expressions/Templates/Compilation/TemplateCompiler.cs

@@ -1,11 +1,14 @@
-using Serilog.Expressions.Parsing;
+using Serilog.Expressions.Ast;
+using Serilog.Expressions.Parsing;
 using Serilog.Parsing;
 using Serilog.Templates.Ast;
 using Superpower;
 using Superpower.Model;
 using Superpower.Parsers;
 using static Serilog.Expressions.Parsing.ExpressionToken;
 
+// ReSharper disable SuggestBaseTypeForParameter, ConvertIfStatementToSwitchStatement, AccessToModifiedClosure
+
 namespace Serilog.Templates.Parsing
 {
     class TemplateTokenParsers
@@ -14,33 +17,76 @@ class TemplateTokenParsers
 
         public TemplateTokenParsers()
         {
+            TokenListParser<ExpressionToken, Template>? block = null;
+
             var alignment =
                 Token.EqualTo(Comma).IgnoreThen(
                     (from direction in Token.EqualTo(Minus).Value(AlignmentDirection.Left)
                             .OptionalOrDefault(AlignmentDirection.Right)
                         from width in Token.EqualTo(Number).Apply(Numerics.NaturalUInt32)
-                        select new Alignment(direction, (int)width)).Named("alignment and width"));
-                    
+                        select new Alignment(direction, (int) width)).Named("alignment and width"));
+
             var format = Token.EqualTo(Colon)
                 .IgnoreThen(Token.EqualTo(Format))
-                .Select(fmt => (string?)fmt.ToStringValue());
-            
+                .Select(fmt => (string?) fmt.ToStringValue());
+
             var hole =
                 from _ in Token.EqualTo(LBrace)
                 from expr in ExpressionTokenParsers.Expr
                 from align in alignment.OptionalOrDefault()
                 from fmt in format.OptionalOrDefault()
                 from __ in Token.EqualTo(RBrace)
                 select (Template) new FormattedExpression(expr, fmt, align);
+
+            static TokenListParser<ExpressionToken, Expression?> Directive(
+                bool hasArgument,
+                params ExpressionToken[] signifiers)
+            {
+                var open = Token.EqualTo(LBraceHash)
+                    .IgnoreThen(Token.Sequence(signifiers)).Try();
+
+                if (hasArgument)
+                    return open
+                        .IgnoreThen(ExpressionTokenParsers.Expr.Cast<ExpressionToken, Expression, Expression?>())
+                        .Then(v => Token.EqualTo(RBrace).Value(v));
+                
+                return open.IgnoreThen(Token.EqualTo(RBrace)).Value((Expression?)null);
+            }
+
+            static Template? LeftReduceConditional((Expression?, Template)[] first, Template? last)
+            {
+                for (var i = first.Length -1; i >= 0; i--)
+                {
+                    last = new Conditional(first[i].Item1!, first[i].Item2, last);
+                }
+
+                return last;
+            }
+
+            var conditional =
+                from iff in Directive(true, If)
+                from consequent in Parse.Ref(() => block)
+                from alternatives in Directive(true, Else, If)
+                    .Then(elsif => Parse.Ref(() => block).Select(b => (elsif, b)))
+                    .Many()
+                from final in Directive(false, Else)
+                    .IgnoreThen(Parse.Ref(() => block).Select(b => ((Expression?) null, b)))
+                    .OptionalOrDefault()
+                from _ in Directive(false, End)
+                let firstAlt = LeftReduceConditional(alternatives, final.b)
+                select (Template)new Conditional(iff!, consequent, firstAlt);
 
             var element = Token.EqualTo(Text).Select(t => (Template)new LiteralText(t.ToStringValue()))
                 .Or(Token.EqualTo(DoubleLBrace)
                     .Value((Template) new LiteralText("{")))
                 .Or(Token.EqualTo(DoubleRBrace)
                     .Value((Template) new LiteralText("}")))
+                .Or(conditional)
                 .Or(hole);
 
-            var block = element.Many().Select(elements => (Template) new TemplateBlock(elements));
+            block = element.Many().Select(elements => elements.Length == 1 ?
+                elements[0] :
+                new TemplateBlock(elements));
 
             _template = block.AtEnd();
         }

src/Serilog.Expressions/Templates/Parsing/TemplateTokenParsers.cs

@@ -37,8 +37,16 @@ protected override IEnumerable<Result<ExpressionToken>> Tokenize(TextSpan span)
                     }
                     else
                     {
-                        yield return Result.Value(ExpressionToken.LBrace, next.Location, next.Remainder);
-                        start = rem = next.Remainder;
+                        if (peek.HasValue && peek.Value == '#')
+                        {
+                            yield return Result.Value(ExpressionToken.LBraceHash, next.Location, peek.Remainder);
+                            start = rem = peek.Remainder;
+                        }
+                        else
+                        {
+                            yield return Result.Value(ExpressionToken.LBrace, next.Location, next.Remainder);
+                            start = rem = next.Remainder;
+                        }
 
                         foreach (var token in TokenizeHole(rem))
                         {

src/Serilog.Expressions/Templates/Parsing/TemplateTokenizer.cs

@@ -13,3 +13,5 @@ Aligned {42,4}!                          ⇶ Aligned   42!
 Left {42,-4}!                            ⇶ Left 42  !
 Under width {42,0}!                      ⇶ Under width 42!
 {@m}                                     ⇶ Hello, nblumhardt!
+Hello, {#if 1 = 1}world{#end}!           ⇶ Hello, world!
+Hello, {#if true}world{#else}there{#end}! ⇶ Hello, world!