Objects and conditionals

Author: nblumhardt

src/Serilog.Expressions/Expressions/Ast/ArrayExpression.cs

@@ -14,7 +14,7 @@ public ArrayExpression(Expression[] elements)
 
         public override string ToString()
         {
-            return "[" + string.Join(",", Elements.Select(o => o.ToString())) + "]";
+            return "[" + string.Join(", ", Elements.Select(o => o.ToString())) + "]";
         }
     }
 }

src/Serilog.Expressions/Expressions/Ast/CallExpression.cs

@@ -22,7 +22,7 @@ public override string ToString()
                 return Operands[0] + "[" + Operands[1] + "]";
             }
 
-            return OperatorName + "(" + string.Join(",", Operands.Select(o => o.ToString())) + ")";
+            return OperatorName + "(" + string.Join(", ", Operands.Select(o => o.ToString())) + ")";
         }
     }
 }

src/Serilog.Expressions/Expressions/Ast/ObjectExpression.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Linq;
+using Serilog.Events;
+
+namespace Serilog.Expressions.Ast
+{
+    class ObjectExpression : Expression
+    {
+        public ObjectExpression(KeyValuePair<string, Expression>[] members)
+        {
+            Members = members;
+        }
+     
+        public KeyValuePair<string, Expression>[] Members { get; }
+
+        public override string ToString()
+        {
+            return "{" + string.Join(", ", Members.Select(m => $"{new ScalarValue(m.Key)}: {m.Value}")) + "}";
+        }
+    }
+}

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

@@ -1,4 +1,5 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using System.Text.RegularExpressions;
 using Serilog.Events;
 using Serilog.Expressions.Runtime;
@@ -9,14 +10,29 @@ static class Intrinsics
     {
         static readonly LogEventPropertyValue NegativeOne = new ScalarValue(-1);
 
-        public static LogEventPropertyValue? ConstructSequenceValue(LogEventPropertyValue[] elements)
+        public static LogEventPropertyValue? ConstructSequenceValue(LogEventPropertyValue?[] elements)
         {
             // Avoid upsetting Serilog's (currently) fragile `SequenceValue.Render()`.
             if (elements.Any(el => el == null))
                 return null;
             return new SequenceValue(elements);
         }
 
+        public static LogEventPropertyValue? ConstructStructureValue(string[] names, LogEventPropertyValue?[] values)
+        {
+            var properties = new List<LogEventProperty>();
+            for (var i = 0; i < names.Length; ++i)
+            {
+                var value = values[i];
+                
+                // Avoid upsetting Serilog's `Structure.Render()`.
+                if (value == null) return null;
+                
+                properties.Add(new LogEventProperty(names[i], value));
+            }
+            return new StructureValue(properties);
+        }
+        
         public static bool CoerceToScalarBoolean(LogEventPropertyValue value)
         {
             if (value is ScalarValue sv && sv.Value is bool b)

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

@@ -25,6 +25,9 @@ class LinqExpressionCompiler : SerilogExpressionTransformer<ExpressionBody>
         static readonly MethodInfo ConstructSequenceValueMethod = typeof(Intrinsics)
             .GetMethod(nameof(Intrinsics.ConstructSequenceValue), BindingFlags.Static | BindingFlags.Public)!;
 
+        static readonly MethodInfo ConstructStructureValueMethod = typeof(Intrinsics)
+            .GetMethod(nameof(Intrinsics.ConstructStructureValue), BindingFlags.Static | BindingFlags.Public)!;
+
         static readonly MethodInfo CoerceToScalarBooleanMethod = typeof(Intrinsics)
             .GetMethod(nameof(Intrinsics.CoerceToScalarBoolean), BindingFlags.Static | BindingFlags.Public)!;
 
@@ -161,6 +164,28 @@ protected override ExpressionBody Transform(ArrayExpression ax)
             var arr = LX.NewArrayInit(typeof(LogEventPropertyValue), elements);
             return LX.Call(ConstructSequenceValueMethod, arr);
         }
+        
+        protected override ExpressionBody Transform(ObjectExpression ox)
+        {
+            var names = new List<string>();
+            var values = new List<ExpressionBody>();
+            foreach (var member in ox.Members)
+            {
+                if (names.Contains(member.Key))
+                {
+                    var oldPos = names.IndexOf(member.Key);
+                    values[oldPos] = Transform(member.Value);
+                }
+                else
+                {
+                    names.Add(member.Key);
+                    values.Add(Transform(member.Value));
+                }
+            }
+            var namesConstant = LX.Constant(names.ToArray(), typeof(string[]));
+            var valuesArr = LX.NewArrayInit(typeof(LogEventPropertyValue), values.ToArray());
+            return LX.Call(ConstructStructureValueMethod, namesConstant, valuesArr);
+        }
 
         protected override ExpressionBody Transform(IndexerExpression ix)
         {

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

@@ -5,7 +5,7 @@ namespace Serilog.Expressions.Compilation.Transformations
 {
     abstract class SerilogExpressionTransformer<TResult>
     {
-        protected TResult Transform(Expression expression)
+        protected virtual TResult Transform(Expression expression)
         {
             return expression switch
             {
@@ -17,6 +17,7 @@ protected TResult Transform(Expression expression)
                 ParameterExpression parameter => Transform(parameter),
                 IndexerWildcardExpression wildcard => Transform(wildcard),
                 ArrayExpression array => Transform(array),
+                ObjectExpression obj => Transform(obj),
                 IndexerExpression indexer => Transform(indexer),
                 IndexOfMatchExpression match => Transform(match),
                 null => throw new ArgumentNullException(nameof(expression)),
@@ -33,6 +34,7 @@ protected TResult Transform(Expression expression)
         protected abstract TResult Transform(ParameterExpression prx);
         protected abstract TResult Transform(IndexerWildcardExpression wx);
         protected abstract TResult Transform(ArrayExpression ax);
+        protected abstract TResult Transform(ObjectExpression ox);
         protected abstract TResult Transform(IndexerExpression ix);
         protected abstract TResult Transform(IndexOfMatchExpression mx);
     }

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

@@ -83,6 +83,23 @@ protected override Expression Transform(ArrayExpression ax)
             return new ArrayExpression(elements.ToArray());
         }
 
+        protected override Expression Transform(ObjectExpression ox)
+        {
+            var any = false;
+            var members = new List<KeyValuePair<string, Expression>>();
+            foreach (var m in ox.Members)
+            {
+                if (TryTransform(m.Value, out var result))
+                    any = true;
+                members.Add(KeyValuePair.Create(m.Key, result));
+            }
+
+            if (!any)
+                return ox;
+
+            return new ObjectExpression(members.ToArray());
+        }
+
         protected override Expression Transform(IndexerExpression ix)
         {
             var transformedRecv = TryTransform(ix.Receiver, out var recv);

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

@@ -19,84 +19,12 @@ public static Expression Replace(Expression expr, Expression source, Expression
             _dest = dest;
         }
 
-        protected override Expression Transform(CallExpression lx)
+        protected override Expression Transform(Expression x)
         {
-            if (lx == _source)
+            if (x == _source)
                 return _dest;
 
-            return base.Transform(lx);
-        }
-
-        protected override Expression Transform(ConstantExpression cx)
-        {
-            if (cx == _source)
-                return _dest;
-
-            return base.Transform(cx);
-        }
-
-        protected override Expression Transform(AmbientPropertyExpression px)
-        {
-            if (px == _source)
-                return _dest;
-
-            return base.Transform(px);
-        }
-
-        protected override Expression Transform(AccessorExpression spx)
-        {
-            if (spx == _source)
-                return _dest;
-
-            return base.Transform(spx);
-        }
-
-        protected override Expression Transform(LambdaExpression lmx)
-        {
-            if (lmx == _source)
-                return _dest;
-
-            return base.Transform(lmx);
-        }
-
-        protected override Expression Transform(ParameterExpression prx)
-        {
-            if (prx == _source)
-                return _dest;
-
-            return base.Transform(prx);
-        }
-
-        protected override Expression Transform(IndexerWildcardExpression wx)
-        {
-            if (wx == _source)
-                return _dest;
-
-            return base.Transform(wx);
-        }
-
-        protected override Expression Transform(IndexerExpression ix)
-        {
-            if (ix == _source)
-                return _dest;
-            
-            return base.Transform(ix);
-        }
-        
-        protected override Expression Transform(ArrayExpression ax)
-        {
-            if (ax == _source)
-                return _dest;
-            
-            return base.Transform(ax);
-        }
-
-        protected override Expression Transform(IndexOfMatchExpression mx)
-        {
-            if (mx == _source)
-                return _dest;
-            
-            return base.Transform(mx);
+            return base.Transform(x);
         }
     }
 }

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

@@ -66,5 +66,10 @@ class WildcardSearch : SerilogExpressionTransformer<IndexerExpression?>
         {
             return Transform(mx.Corpus);
         }
+
+        protected override IndexerExpression? Transform(ObjectExpression ox)
+        {
+            return null;
+        }
     }
 }

src/Serilog.Expressions/Expressions/Operators.cs

@@ -57,6 +57,7 @@ static class Operators
         public const string OpSubstring = "Substring";
         public const string OpIndexOfMatch = "IndexOfMatch";
         public const string OpIsMatch = "IsMatch";
+        public const string RuntimeOpIfThenElse = "_Internal_IfThenElse";
 
         public static readonly HashSet<string> WildcardComparators = new HashSet<string>(OperatorComparer)
         {