Accept a single name resolver rather than an ordered list when providing one to Compile() etc.

Author: nblumhardt

src/Serilog.Expressions/Expressions/Compilation/DefaultFunctionNameResolver.cs

@@ -1,18 +1,15 @@
-using System.Collections.Generic;
-using System.Linq;
-using Serilog.Expressions.Runtime;
+using Serilog.Expressions.Runtime;
 
 namespace Serilog.Expressions.Compilation
 {
     static class DefaultFunctionNameResolver
     {
-        public static NameResolver Build(IEnumerable<NameResolver>? orderedResolvers)
+        public static NameResolver Build(NameResolver? additionalNameResolver)
         {
             var defaultResolver = new StaticMemberNameResolver(typeof(RuntimeOperators));
-            return orderedResolvers == null
+            return additionalNameResolver == null
                 ? (NameResolver) defaultResolver
-                : new OrderedNameResolver(
-                    new NameResolver[] {defaultResolver}.Concat(orderedResolvers));
+                : new OrderedNameResolver(new[] {defaultResolver, additionalNameResolver });
         }
     }
 }

src/Serilog.Expressions/Expressions/SerilogExpression.cs

@@ -32,15 +32,15 @@ public static class SerilogExpression
         /// Create an evaluation function based on the provided expression.
         /// </summary>
         /// <param name="expression">An expression.</param>
-        /// <param name="orderedResolvers">Optionally, an ordered list of <see cref="NameResolver"/>s
-        /// from which to resolve function names that appear in the template.</param>
+        /// <param name="nameResolver">Optionally, a <see cref="NameResolver"/>
+        /// with which to resolve function names that appear in the template.</param>
         /// <returns>A function that evaluates the expression in the context of a log event.</returns>
         public static CompiledExpression Compile(
             string expression,
-            IEnumerable<NameResolver>? orderedResolvers = null)
+            NameResolver? nameResolver = null)
         {
             if (expression == null) throw new ArgumentNullException(nameof(expression));
-            if (!TryCompileImpl(expression, orderedResolvers, out var filter, out var error))
+            if (!TryCompileImpl(expression, nameResolver, out var filter, out var error))
                 throw new ArgumentException(error);
 
             return filter;
@@ -70,25 +70,25 @@ public static bool TryCompile(
         /// <param name="expression">An expression.</param>
         /// <param name="result">A function that evaluates the expression in the context of a log event.</param>
         /// <param name="error">The reported error, if compilation was unsuccessful.</param>
-        /// <param name="orderedResolvers">An ordered list of <see cref="NameResolver"/>s
-        /// from which to resolve function names that appear in the template.</param>
+        /// <param name="nameResolver">A <see cref="NameResolver"/>
+        /// with which to resolve function names that appear in the template.</param>
         /// <returns>True if the function could be created; otherwise, false.</returns>
         /// <remarks>Regular expression syntax errors currently generate exceptions instead of producing friendly
         /// errors.</remarks>
         public static bool TryCompile(
             string expression,
-            IEnumerable<NameResolver> orderedResolvers,
+            NameResolver nameResolver,
             [MaybeNullWhen(false)] out CompiledExpression result,
             [MaybeNullWhen(true)] out string error)
         {
             if (expression == null) throw new ArgumentNullException(nameof(expression));
-            if (orderedResolvers == null) throw new ArgumentNullException(nameof(orderedResolvers));
-            return TryCompileImpl(expression, orderedResolvers, out result, out error);
+            if (nameResolver == null) throw new ArgumentNullException(nameof(nameResolver));
+            return TryCompileImpl(expression, nameResolver, out result, out error);
         }
 
         static bool TryCompileImpl(
             string expression,
-            IEnumerable<NameResolver>? orderedResolvers,
+            NameResolver? nameResolver,
             [MaybeNullWhen(false)] out CompiledExpression result,
             [MaybeNullWhen(true)] out string error)
         {
@@ -98,7 +98,7 @@ static bool TryCompileImpl(
                 return false;
             }
 
-            result = ExpressionCompiler.Compile(root, DefaultFunctionNameResolver.Build(orderedResolvers));
+            result = ExpressionCompiler.Compile(root, DefaultFunctionNameResolver.Build(nameResolver));
             error = null;
             return true;
         }

src/Serilog.Expressions/Templates/ExpressionTemplate.cs

@@ -43,13 +43,13 @@ public static bool TryParse(
         /// embedded values.</param>
         /// <param name="result">The parsed template, if successful.</param>
         /// <param name="error">A description of the error, if unsuccessful.</param>
-        /// <param name="orderedResolvers">Optionally, an ordered list of <see cref="NameResolver"/>s
-        /// from which to resolve function names that appear in the template.</param>
+        /// <param name="nameResolver">Optionally, a <see cref="NameResolver"/>
+        /// with which to resolve function names that appear in the template.</param>
         /// <returns><c langword="true">true</c> if the template was well-formed.</returns>
         public static bool TryParse(
             string template,
             IFormatProvider? formatProvider,
-            IEnumerable<NameResolver>? orderedResolvers,
+            NameResolver? nameResolver,
             [MaybeNullWhen(false)] out ExpressionTemplate result,
             [MaybeNullWhen(true)] out string error)
         {
@@ -61,7 +61,7 @@ public static bool TryParse(
                 return false;
             }
 
-            result = new ExpressionTemplate(TemplateCompiler.Compile(parsed, DefaultFunctionNameResolver.Build(orderedResolvers)), formatProvider);
+            result = new ExpressionTemplate(TemplateCompiler.Compile(parsed, DefaultFunctionNameResolver.Build(nameResolver)), formatProvider);
             return true;
         }
 
@@ -77,19 +77,19 @@ public static bool TryParse(
         /// <param name="template">The template text.</param>
         /// <param name="formatProvider">Optionally, an <see cref="IFormatProvider"/> to use when formatting
         /// embedded values.</param>
-        /// <param name="orderedResolvers">Optionally, an ordered list of <see cref="NameResolver"/>s
-        /// from which to resolve function names that appear in the template.</param>
+        /// <param name="nameResolver">Optionally, a <see cref="NameResolver"/>
+        /// with which to resolve function names that appear in the template.</param>
         public ExpressionTemplate(
             string template,
             IFormatProvider? formatProvider = null,
-            IEnumerable<NameResolver>? orderedResolvers = null)
+            NameResolver? nameResolver = null)
         {
             if (template == null) throw new ArgumentNullException(nameof(template));
 
             if (!TemplateParser.TryParse(template, out var parsed, out var error))
                 throw new ArgumentException(error);
 
-            _compiled = TemplateCompiler.Compile(parsed, DefaultFunctionNameResolver.Build(orderedResolvers));
+            _compiled = TemplateCompiler.Compile(parsed, DefaultFunctionNameResolver.Build(nameResolver));
             _formatProvider = formatProvider;
         }
 

test/Serilog.Expressions.Tests/NameResolverTests.cs

@@ -20,7 +20,7 @@ public void UserDefinedFunctionsAreCallableInExpressions()
         {
             var expr = SerilogExpression.Compile(
                 "magic(10) + 3 = 55",
-                new[] {new StaticMemberNameResolver(typeof(NameResolverTests))});
+                new StaticMemberNameResolver(typeof(NameResolverTests)));
             Assert.True(Coerce.IsTrue(expr(Some.InformationEvent())));
         }
     }