More repetition WIP

Author: nblumhardt

src/Serilog.Expressions/Expressions/Ast/NamedLocalExpression.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Serilog.Expressions.Ast
+{
+    class NamedLocalExpression : Expression
+    {
+        public NamedLocalExpression(string name)
+        {
+            Name = name ?? throw new ArgumentNullException(nameof(name));
+        }
+
+        public string Name { get; }
+
+        public override string ToString()
+        {
+            // No unambiguous syntax for this right now, `$` will do to make these stand out when debugging,
+            // but the result won't round-trip parse.
+            return $"${Name}";
+        }
+    }
+}

src/Serilog.Expressions/Expressions/Compilation/Linq/Intrinsics.cs

@@ -134,8 +134,15 @@ public static bool CoerceToScalarBoolean(LogEventPropertyValue value)
 
         public static LogEventPropertyValue? GetPropertyValue(EvaluationContext ctx, string propertyName)
         {
-            if (!Locals.TryGetValue(ctx.Locals, propertyName, out var value) &&
-                !ctx.LogEvent.Properties.TryGetValue(propertyName, out value))
+            if (!ctx.LogEvent.Properties.TryGetValue(propertyName, out var value))
+                return null;
+
+            return value;
+        }
+
+        public static LogEventPropertyValue? GetLocalValue(EvaluationContext ctx, string localName)
+        {
+            if (!Locals.TryGetValue(ctx.Locals, localName, out var value))
                 return null;
 
             return value;

src/Serilog.Expressions/Expressions/Compilation/Linq/LinqExpressionCompiler.cs

@@ -156,10 +156,18 @@ protected override ExpressionBody Transform(AmbientPropertyExpression px)
                 };
             }
 
+            // Don't close over the AST node.
             var propertyName = px.PropertyName;
             return Splice(context => Intrinsics.GetPropertyValue(context, propertyName));
         }
 
+        protected override ExpressionBody Transform(NamedLocalExpression nlx)
+        {
+            // Don't close over the AST node.
+            var name = nlx.Name;
+            return Splice(context => Intrinsics.GetLocalValue(context, name));
+        }
+
         protected override ExpressionBody Transform(Ast.LambdaExpression lmx)
         {
             var parameters = lmx.Parameters.Select(px => Tuple.Create(px, LX.Parameter(typeof(LogEventPropertyValue), px.ParameterName))).ToList();

src/Serilog.Expressions/Expressions/Compilation/Transformations/FilterExpressionTransformer`1.cs

@@ -29,6 +29,7 @@ protected virtual TResult Transform(Expression expression)
         protected abstract TResult Transform(CallExpression lx);
         protected abstract TResult Transform(ConstantExpression cx);
         protected abstract TResult Transform(AmbientPropertyExpression px);
+        protected abstract TResult Transform(NamedLocalExpression nlx);
         protected abstract TResult Transform(AccessorExpression spx);
         protected abstract TResult Transform(LambdaExpression lmx);
         protected abstract TResult Transform(ParameterExpression prx);

src/Serilog.Expressions/Expressions/Compilation/Transformations/IdentityTransformer.cs

@@ -38,6 +38,11 @@ protected override Expression Transform(AmbientPropertyExpression px)
             return px;
         }
 
+        protected override Expression Transform(NamedLocalExpression nlx)
+        {
+            return nlx;
+        }
+
         protected override Expression Transform(AccessorExpression spx)
         {
             if (!TryTransform(spx.Receiver, out var recv))

src/Serilog.Expressions/Expressions/Compilation/Wildcards/WildcardSearch.cs

@@ -31,6 +31,11 @@ class WildcardSearch : SerilogExpressionTransformer<IndexerExpression?>
             return null;
         }
 
+        protected override IndexerExpression? Transform(NamedLocalExpression nlx)
+        {
+            return null;
+        }
+
         protected override IndexerExpression? Transform(AccessorExpression spx)
         {
             return Transform(spx.Receiver);

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

@@ -0,0 +1,31 @@
+using System;
+using Serilog.Expressions.Ast;
+
+namespace Serilog.Templates.Ast
+{
+    class Repetition: Template
+    {
+        public Expression Enumerable { get; }
+        public string? KeyOrElementName { get; }
+        public string? ValueName { get; }
+        public Template Body { get; }
+        public Template? Separator { get; }
+        public Template? Alternative { get; }
+
+        public Repetition(
+            Expression enumerable,
+            string? keyOrElementName,
+            string? valueName,
+            Template body,
+            Template? separator,
+            Template? alternative)
+        {
+            Enumerable = enumerable ?? throw new ArgumentNullException(nameof(enumerable));
+            KeyOrElementName = keyOrElementName;
+            ValueName = valueName;
+            Body = body ?? throw new ArgumentNullException(nameof(body));
+            Separator = separator;
+            Alternative = alternative;
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Serilog.Expressions.Ast;
+using Serilog.Expressions.Compilation.Transformations;
+
+namespace Serilog.Templates.Compilation.NameResolution
+{
+    class ExpressionLocalNameBinder : IdentityTransformer
+    {
+        readonly IReadOnlyCollection<string> _localNames;
+
+        public static Expression BindLocalValueNames(Expression expression, IReadOnlyCollection<string> locals)
+        {
+            var expressionLocalNameBinder = new ExpressionLocalNameBinder(locals);
+            return expressionLocalNameBinder.Transform(expression);
+        }
+
+        ExpressionLocalNameBinder(IReadOnlyCollection<string> localNames)
+        {
+            _localNames = localNames ?? throw new ArgumentNullException(nameof(localNames));
+        }
+        
+        protected override Expression Transform(AmbientPropertyExpression px)
+        {
+            if (!px.IsBuiltIn && _localNames.Contains(px.PropertyName))
+                return new NamedLocalExpression(px.PropertyName);
+            
+            return base.Transform(px);
+        }
+    }
+}

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

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Serilog.Templates.Ast;
+
+// ReSharper disable MemberCanBeMadeStatic.Local, SuggestBaseTypeForParameter
+
+namespace Serilog.Templates.Compilation.NameResolution
+{
+    class TemplateLocalNameBinder
+    {
+        public static Template BindLocalValueNames(Template template)
+        {
+            var binder = new TemplateLocalNameBinder();
+            return binder.Transform(template, new Stack<string>());
+        }
+
+        Template Transform(Template template, Stack<string> locals)
+        {
+            return template switch
+            {
+                TemplateBlock block => Transform(block, locals),
+                LiteralText text => text,
+                FormattedExpression fx => Transform(fx, locals),
+                Conditional cond => Transform(cond, locals),
+                Repetition rep => Transform(rep, locals),
+                _ => throw new NotSupportedException("Unsupported template type.")
+            };
+        }
+
+        Template Transform(TemplateBlock block, Stack<string> locals)
+        {
+            return new TemplateBlock(block.Elements
+                .Select(e => Transform(e, locals))
+                .ToArray());
+        }
+
+        Template Transform(FormattedExpression fx, Stack<string> locals)
+        {
+            if (locals.Count == 0)
+                return fx;
+            
+            return new FormattedExpression(
+                ExpressionLocalNameBinder.BindLocalValueNames(fx.Expression, locals),
+                fx.Format,
+                fx.Alignment);
+        }
+
+        Template Transform(Conditional cond, Stack<string> locals)
+        {
+            return new Conditional(
+                cond.Condition,
+                cond.Consequent,
+                cond.Alternative != null ? Transform(cond.Alternative, locals) : null);
+        }
+
+        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);
+
+            var body = Transform(rep.Body, locals);
+
+            while (locals.Count != orig)
+                locals.Pop();
+            
+            return new Repetition(
+                rep.Enumerable,
+                rep.KeyOrElementName,
+                rep.ValueName,
+                body,
+                rep.Separator != null ? Transform(rep.Separator, locals) : null,
+                rep.Alternative != null ? Transform(rep.Alternative, locals) : null);
+        }
+    }
+}