More repetition WIP

Author: nblumhardt

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

@@ -5,9 +5,6 @@ namespace Serilog.Expressions.Parsing
     enum ExpressionToken
     {
         None,
-        
-        [Token(Description = "literal text")]
-        TemplateLiteral,
 
         Identifier,
 
@@ -148,5 +145,11 @@ enum ExpressionToken
 
         [Token(Category = "keyword", Example = "end")]
         End,
+        
+        [Token(Category = "keyword", Example = "each")]
+        Each,
+
+        [Token(Category = "keyword", Example = "delimit")]
+        Delimit,
     }
 }

src/Serilog.Expressions/Expressions/Runtime/Local.cs renamed to src/Serilog.Expressions/Expressions/Runtime/Locals.cs

@@ -6,25 +6,22 @@ namespace Serilog.Templates.Ast
     class Repetition: Template
     {
         public Expression Enumerable { get; }
-        public string? KeyOrElementName { get; }
-        public string? ValueName { get; }
+        public string[] BindingNames { get; }
         public Template Body { get; }
-        public Template? Separator { get; }
+        public Template? Delimiter { get; }
         public Template? Alternative { get; }
 
         public Repetition(
             Expression enumerable,
-            string? keyOrElementName,
-            string? valueName,
+            string[] bindingNames,
             Template body,
-            Template? separator,
+            Template? delimiter,
             Template? alternative)
         {
             Enumerable = enumerable ?? throw new ArgumentNullException(nameof(enumerable));
-            KeyOrElementName = keyOrElementName;
-            ValueName = valueName;
+            BindingNames = bindingNames;
             Body = body ?? throw new ArgumentNullException(nameof(body));
-            Separator = separator;
+            Delimiter = delimiter;
             Alternative = alternative;
         }
     }

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

@@ -12,22 +12,22 @@ class CompiledRepetition : CompiledTemplate
         readonly string? _keyOrElementName;
         readonly string? _valueName;
         readonly CompiledTemplate _body;
-        readonly CompiledTemplate? _separator;
+        readonly CompiledTemplate? _delimiter;
         readonly CompiledTemplate? _alternative;
 
         public CompiledRepetition(
             Evaluatable enumerable,
             string? keyOrElementName,
             string? valueName,
             CompiledTemplate body,
-            CompiledTemplate? separator,
+            CompiledTemplate? delimiter,
             CompiledTemplate? alternative)
         {
             _enumerable = enumerable;
             _keyOrElementName = keyOrElementName;
             _valueName = valueName;
             _body = body;
-            _separator = separator;
+            _delimiter = delimiter;
             _alternative = alternative;
         }
 
@@ -58,7 +58,7 @@ public override void Evaluate(EvaluationContext ctx, TextWriter output, IFormatP
                     if (first)
                     {
                         first = false;
-                        _separator?.Evaluate(ctx, output, formatProvider);
+                        _delimiter?.Evaluate(ctx, output, formatProvider);
                     }
 
                     var local = _keyOrElementName != null
@@ -85,7 +85,7 @@ public override void Evaluate(EvaluationContext ctx, TextWriter output, IFormatP
                     if (first)
                     {
                         first = false;
-                        _separator?.Evaluate(ctx, output, formatProvider);
+                        _delimiter?.Evaluate(ctx, output, formatProvider);
                     }
 
                     var local = _keyOrElementName != null
@@ -114,7 +114,7 @@ public override void Evaluate(EvaluationContext ctx, TextWriter output, IFormatP
                     if (first)
                     {
                         first = false;
-                        _separator?.Evaluate(ctx, output, formatProvider);
+                        _delimiter?.Evaluate(ctx, output, formatProvider);
                     }
 
                     var local = _keyOrElementName != null

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

@@ -56,23 +56,19 @@ Template Transform(Conditional cond, Stack<string> locals)
 
         Template Transform(Repetition rep, Stack<string> locals)
         {
-            var orig = locals.Count;
-            if (rep.KeyOrElementName != null)
-                locals.Push(rep.KeyOrElementName);
-            if (rep.ValueName != null)
-                locals.Push(rep.ValueName);
+            foreach (var name in rep.BindingNames)
+                locals.Push(name);
 
             var body = Transform(rep.Body, locals);
 
-            while (locals.Count != orig)
+            foreach (var _ in rep.BindingNames)
                 locals.Pop();
 
             return new Repetition(
                 rep.Enumerable,
-                rep.KeyOrElementName,
-                rep.ValueName,
+                rep.BindingNames,
                 body,
-                rep.Separator != null ? Transform(rep.Separator, locals) : null,
+                rep.Delimiter != null ? Transform(rep.Delimiter, locals) : null,
                 rep.Alternative != null ? Transform(rep.Alternative, locals) : null);
         }
     }

src/Serilog.Expressions/Templates/Compilation/NameResolution/TemplateLocalNameResolver.cs

@@ -21,6 +21,13 @@ public static CompiledTemplate Compile(Template template, NameResolver nameResol
                     ExpressionCompiler.Compile(conditional.Condition, nameResolver),
                     Compile(conditional.Consequent, nameResolver),
                     conditional.Alternative == null ? null : Compile(conditional.Alternative, nameResolver)),
+                Repetition repetition => new CompiledRepetition(
+                    ExpressionCompiler.Compile(repetition.Enumerable, nameResolver),
+                    repetition.BindingNames.Length > 0 ? repetition.BindingNames[0] : null,
+                    repetition.BindingNames.Length > 1 ? repetition.BindingNames[1] : null,
+                    Compile(repetition.Body, nameResolver),
+                    repetition.Delimiter == null ? null : Compile(repetition.Delimiter, nameResolver),
+                    repetition.Alternative == null ? null : Compile(repetition.Alternative, nameResolver)),
                 _ => throw new NotSupportedException()
             };
         }

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

@@ -49,13 +49,13 @@ from __ in Token.EqualTo(RBrace)
                     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);
+
+                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--)
+                for (var i = first.Length - 1; i >= 0; i--)
                 {
                     last = new Conditional(first[i].Item1!, first[i].Item2, last);
                 }
@@ -72,16 +72,47 @@ from alternatives in Directive(true, Else, If)
                 from final in Directive(false, Else)
                     .IgnoreThen(Parse.Ref(() => block).Select(b => ((Expression?) null, b)))
                     .OptionalOrDefault()
-                from _ in Directive(false, End)
+                from end in Directive(false, End)
                 let firstAlt = LeftReduceConditional(alternatives, final.b)
-                select (Template)new Conditional(iff!, consequent, firstAlt);
-            
+                select (Template) new Conditional(iff!, consequent, firstAlt);
+
+            var eachDirective =
+                Token.EqualTo(LBraceHash)
+                    .IgnoreThen(Token.EqualTo(Each)).Try()
+                    .IgnoreThen(Token.EqualTo(ExpressionToken.Identifier)
+                        .Select(i => i.ToStringValue())
+                        .AtLeastOnceDelimitedBy(Token.EqualTo(Comma)))
+                    .Then(bindings => Token.EqualTo(In).Value(bindings))
+                    .Then(bindings => ExpressionTokenParsers.Expr.Cast<ExpressionToken, Expression, Expression?>()
+                        .Select(enumerable => new {enumerable, bindings}))
+                    .Then(v => Token.EqualTo(RBrace).Value(v));
+
+            var repetition =
+                from each in eachDirective
+                from body in Parse.Ref(() => block)
+                from delimiter in Directive(false, Delimit)
+                    .IgnoreThen(Parse.Ref(() => block))
+                    .Cast<ExpressionToken, Template, Template?>()
+                    .OptionalOrDefault()
+                from alternative in Directive(false, Else)
+                    .IgnoreThen(Parse.Ref(() => block))
+                    .Cast<ExpressionToken, Template, Template?>()
+                    .OptionalOrDefault()
+                from end in Directive(false, End)
+                select (Template) new Repetition(
+                    each.enumerable,
+                    each.bindings,
+                    body,
+                    delimiter,
+                    alternative);
+
             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(repetition)
                 .Or(hole);
 
             block = element.Many().Select(elements => elements.Length == 1 ?

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

@@ -21,3 +21,6 @@ Hello, {#if undefined()}world{#else}there{#end}!     ⇶ Hello, there!
 A{#if false}B{#else if false}C{#else if true}D{#else}E{#end} ⇶ AD
 A{#if false}B{#else if true}C{#end}                  ⇶ AC
 {#if true}A{#if false}B{#else}C{#end}D{#end}         ⇶ ACD
+{#each a in [1,2,3]}<{a}>{#delimit},{#end}           ⇶ <1>,<2>,<3>
+{#each a in {x: 1, y: 2}}{a}{#end}                   ⇶ xy
+{#each a, b in {x: 1, y: 2}}{a}.{b}{#end}            ⇶ x.1y.2

test/Serilog.Expressions.Tests/Cases/template-evaluation-cases.asv

@@ -3,7 +3,7 @@
 using Serilog.Expressions.Tests.Support;
 using Xunit;
 
-namespace Serilog.Expressions.Tests
+namespace Serilog.Expressions.Tests.Expressions
 {
     public class NameResolverTests
     {

test/Serilog.Expressions.Tests/NameResolverTests.cs renamed to test/Serilog.Expressions.Tests/Expressions/NameResolverTests.cs

@@ -0,0 +1,45 @@
+using Serilog.Expressions.Runtime;
+using Serilog.Expressions.Tests.Support;
+using Xunit;
+
+namespace Serilog.Expressions.Tests.Expressions.Runtime
+{
+    public class LocalsTests
+    {
+        [Fact]
+        public void NoValueIsDefinedInNoLocals()
+        {
+            Assert.False(Locals.TryGetValue(null, "A", out _));
+        }
+        
+        [Fact]
+        public void ASetValueIsRetrieved()
+        {
+            var expected = Some.LogEventPropertyValue();
+            var locals = Locals.Set(null, "A", expected);
+            Assert.True(Locals.TryGetValue(locals, "A", out var actual));
+            Assert.Same(expected, actual);
+        }
+        
+        [Fact]
+        public void ASetValueIsRetrievedFromMany()
+        {
+            var expected = Some.LogEventPropertyValue();
+            var locals = Locals.Set(null, "A", expected);
+            locals = Locals.Set(locals, "B", Some.LogEventPropertyValue());
+            Assert.True(Locals.TryGetValue(locals, "A", out var actual));
+            Assert.Same(expected, actual);
+        }
+        
+        [Fact]
+        public void TheTopmostValueIsRetrievedForAName()
+        {
+            var expected = Some.LogEventPropertyValue();
+            var locals = Locals.Set(null, "A", Some.LogEventPropertyValue());
+            locals = Locals.Set(locals, "B", Some.LogEventPropertyValue());
+            locals = Locals.Set(locals, "A", expected);
+            Assert.True(Locals.TryGetValue(locals, "A", out var actual));
+            Assert.Same(expected, actual);
+        }
+    }
+}