More scalar value conversion

Author: nblumhardt

src/Serilog.Expressions/Expressions/Ast/ConstantExpression.cs

@@ -1,32 +1,38 @@
 using System;
 using System.Globalization;
+using Serilog.Events;
 
 namespace Serilog.Expressions.Ast
 { 
     class ConstantExpression : Expression
     {
-        public ConstantExpression(object constantValue)
+        public ConstantExpression(LogEventPropertyValue constant)
         {
-            ConstantValue = constantValue;
+            Constant = constant ?? throw new ArgumentNullException(nameof(constant));
         }
 
-        public object ConstantValue { get; }
+        public LogEventPropertyValue Constant { get; }
 
         public override string ToString()
         {
-            switch (ConstantValue)
+            if (Constant is ScalarValue sv)
             {
-                case string s:
-                    return "'" + s.Replace("'", "''") + "'";
-                case true:
-                    return "true";
-                case false:
-                    return "false";
-                case IFormattable formattable:
-                    return formattable.ToString(null, CultureInfo.InvariantCulture);
-                default:
-                    return (ConstantValue ?? "null").ToString();
+                switch (sv.Value)
+                {
+                    case string s:
+                        return "'" + s.Replace("'", "''") + "'";
+                    case true:
+                        return "true";
+                    case false:
+                        return "false";
+                    case IFormattable formattable:
+                        return formattable.ToString(null, CultureInfo.InvariantCulture);
+                    default:
+                        return (sv.Value ?? "null").ToString();
+                }
             }
+
+            return Constant.ToString();
         }
     }
 }

src/Serilog.Expressions/Expressions/Compilation/Arrays/ConstantArrayEvaluator.cs

@@ -23,7 +23,7 @@ protected override Expression Transform(ArrayExpression ax)
                 return new ConstantExpression(
                     new SequenceValue(ax.Elements
                         .Cast<ConstantExpression>()
-                        .Select(ce => Representation.Recapture(ce.ConstantValue))));
+                        .Select(ce => ce.Constant)));
             }
 
             return base.Transform(ax);

src/Serilog.Expressions/Expressions/Compilation/CompiledExpression.cs

@@ -8,13 +8,12 @@
 using Serilog.Expressions.Compilation.Linq;
 using Serilog.Expressions.Compilation.Properties;
 using Serilog.Expressions.Compilation.Wildcards;
-using Serilog.Expressions.Runtime;
 
 namespace Serilog.Expressions.Compilation
 {
     static class ExpressionCompiler
     {
-        public static Func<LogEvent, object> CompileAndExpose(Expression expression)
+        public static CompiledExpression Compile(Expression expression)
         {
             var actual = expression;
             actual = PropertiesObjectAccessorTransformer.Rewrite(actual);
@@ -24,12 +23,7 @@ public static Func<LogEvent, object> CompileAndExpose(Expression expression)
             actual = IsOperatorTransformer.Rewrite(actual);
             actual = EvaluationCostReordering.Reorder(actual);
 
-            var compiled = LinqExpressionCompiler.Compile(actual);
-            return ctx =>
-            {
-                var result = compiled(ctx);
-                return Representation.Expose(result);
-            };
+            return LinqExpressionCompiler.Compile(actual);
         }
     }
 }

src/Serilog.Expressions/Expressions/Compilation/ExpressionCompiler.cs

@@ -17,14 +17,14 @@ protected override Expression Transform(CallExpression lx)
 
             if (lx.Operands[1] is ConstantExpression nul)
             {
-                return nul.ConstantValue != null ? base.Transform(lx) : new CallExpression(Operators.RuntimeOpIsNull, lx.Operands[0]);
+                return nul.Constant != null ? base.Transform(lx) : new CallExpression(Operators.RuntimeOpIsNull, lx.Operands[0]);
             }
 
             if (!(lx.Operands[1] is CallExpression not) || not.Operands.Length != 1)
                 return base.Transform(lx);
 
             nul = not.Operands[0] as ConstantExpression;
-            if (nul == null || nul.ConstantValue != null)
+            if (nul == null || nul.Constant != null)
                 return base.Transform(lx);
 
             return new CallExpression(Operators.RuntimeOpIsNotNull, lx.Operands[0]);

src/Serilog.Expressions/Expressions/Compilation/Is/IsOperatorTransformer.cs

@@ -0,0 +1,29 @@
+using Serilog.Events;
+using Serilog.Expressions.Ast;
+
+namespace Serilog.Expressions.Compilation
+{
+    static class Pattern
+    {
+        public static bool IsAmbientProperty(Expression expression, string name, bool isBuiltIn)
+        {
+            return expression is AmbientPropertyExpression px &&
+                   px.PropertyName == name &&
+                   px.IsBuiltIn == isBuiltIn;
+        }
+
+        public static bool IsStringConstant(Expression expression, out string value)
+        {
+            if (expression is ConstantExpression cx &&
+                cx.Constant is ScalarValue sv &&
+                sv.Value is string s)
+            {
+                value = s;
+                return true;
+            }
+
+            value = null;
+            return false;
+        }
+    }
+}

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

@@ -10,18 +10,20 @@ public static Expression Rewrite(Expression actual)
             return new PropertiesObjectAccessorTransformer().Transform(actual);
         }
 
-        protected override Expression Transform(CallExpression lx)
+        protected override Expression Transform(AccessorExpression ax)
         {
-            if (!Operators.SameOperator(lx.OperatorName, Operators.OpElementAt) || lx.Operands.Length != 2)
-                return base.Transform(lx);
-
-            if (!(lx.Operands[0] is AmbientPropertyExpression p)
-                    || !(lx.Operands[1] is ConstantExpression n)
-                    || !p.IsBuiltIn 
-                    || p.PropertyName != "Properties"
-                    || !(n.ConstantValue is string name))
-                return base.Transform(lx);
+            if (!Pattern.IsAmbientProperty(ax.Receiver, "Properties", true))
+                return base.Transform(ax);
+            
+            return new AmbientPropertyExpression(ax.MemberName, false);
+        }
 
+        protected override Expression Transform(IndexerExpression ix)
+        {
+            if (!Pattern.IsAmbientProperty(ix.Receiver, "Properties", true) ||
+                !Pattern.IsStringConstant(ix.Index, out var name))
+                return base.Transform(ix);
+            
             return new AmbientPropertyExpression(name, false);
         }
     }

src/Serilog.Expressions/Expressions/Compilation/Pattern.cs

@@ -0,0 +1,14 @@
+using Serilog.Events;
+
+#nullable enable
+
+namespace Serilog.Expressions
+{
+    /// <summary>
+    /// A compiled expression evaluated against a <see cref="LogEvent"/>.
+    /// </summary>
+    /// <param name="logEvent"></param>
+    /// <returns>The result of evaluating the expression, represented as a <see cref="LogEventPropertyValue"/>,
+    /// or <c langword="null">null</c> if the result is undefined.</returns>
+    public delegate LogEventPropertyValue? CompiledExpression(LogEvent logEvent);
+}

src/Serilog.Expressions/Expressions/Compilation/Properties/PropertiesObjectAccessorTransformer.cs

@@ -1,4 +1,4 @@
-// Copyright 2013-2015 Serilog Contributors
+// Copyright Serilog Contributors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -27,7 +27,7 @@ public class LoggingFilterSwitch : ILogEventFilter
         // no attempt to synchronize Expression, ToString(), and IsIncluded(),
         // for any observer, this at least ensures they won't be permanently out-of-sync for
         // all observers.
-        volatile Tuple<string, Func<LogEvent, object>> _filter;
+        volatile Tuple<string, CompiledExpression> _filter;
 
         /// <summary>
         /// Construct a <see cref="LoggingFilterSwitch"/>, optionally initialized
@@ -50,6 +50,7 @@ public LoggingFilterSwitch(string expression = null)
         /// </summary>
         public string Expression
         {
+            // ReSharper disable once UnusedMember.Global
             get
             {
                 var filter = _filter;
@@ -63,7 +64,7 @@ public string Expression
                 }
                 else
                 {
-                    _filter = new Tuple<string, Func<LogEvent, object>>(
+                    _filter = new Tuple<string, CompiledExpression>(
                         value,
                         SerilogExpression.Compile(value));
                 }
@@ -80,7 +81,7 @@ public bool IsEnabled(LogEvent logEvent)
             if (filter == null)
                 return true;
 
-            return true.Equals(filter.Item2(logEvent));
+            return true.Equals((filter.Item2(logEvent) as ScalarValue)?.Value);
         }
 
         /// <inheritdoc/>