Add eager/non-throwing validation for expression syntax errors

- Replace pre-validation with exception-based approach
- Invalid regex and unknown functions now return friendly errors via TryCompile
- CI modifier on non-supporting functions logs warnings instead of throwing (backward compatibility)
- Use dynamic StringComparison parameter detection instead of hard-coded function lists

Author: willibrandon

src/Serilog.Expressions/Expressions/Compilation/ExpressionValidationException.cs

@@ -0,0 +1,26 @@
+// 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.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Serilog.Expressions.Compilation;
+
+class ExpressionValidationException : ArgumentException
+{
+    public ExpressionValidationException(string message) : base(message)
+    {
+    }
+
+    public ExpressionValidationException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}

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

@@ -16,6 +16,7 @@
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Text;
+using Serilog.Debugging;
 using Serilog.Events;
 using Serilog.Expressions.Ast;
 using Serilog.Expressions.Compilation.Transformations;
@@ -99,12 +100,24 @@ ExpressionBody Splice(Expression<Evaluatable> lambda)
     protected override ExpressionBody Transform(CallExpression call)
     {
         if (!_nameResolver.TryResolveFunctionName(call.OperatorName, out var m))
-            throw new ArgumentException($"The function name `{call.OperatorName}` was not recognized.");
+            throw new ExpressionValidationException($"The function name `{call.OperatorName}` was not recognized.");
 
         var methodParameters = m.GetParameters()
             .Select(info => (pi: info, optional: info.GetCustomAttribute<OptionalAttribute>() != null))
             .ToList();
 
+        // Log warning for CI modifier usage on functions that don't support it
+        // Note: We log a warning rather than throwing to maintain backward compatibility
+        // Previously, invalid CI usage was silently ignored
+        if (call.IgnoreCase)
+        {
+            var supportsStringComparison = methodParameters.Any(p => p.pi.ParameterType == typeof(StringComparison));
+            if (!supportsStringComparison)
+            {
+                SelfLog.WriteLine($"The function `{call.OperatorName}` does not support case-insensitive operation; the 'ci' modifier will be ignored.");
+            }
+        }
+
         var allowedParameters = methodParameters.Where(info => info.pi.ParameterType == typeof(LogEventPropertyValue)).ToList();
         var requiredParameterCount = allowedParameters.Count(info => !info.optional);
 

src/Serilog.Expressions/Expressions/Compilation/Text/TextMatchingTransformer.cs

@@ -61,8 +61,7 @@ Expression TryCompileIndexOfMatch(bool ignoreCase, Expression corpus, Expression
             }
             catch (ArgumentException ex)
             {
-                SelfLog.WriteLine($"Serilog.Expressions: Invalid regular expression in `IndexOfMatch()`: {ex.Message}");
-                return new CallExpression(false, Operators.OpUndefined);
+                throw new ExpressionValidationException($"Invalid regular expression in IndexOfMatch: {ex.Message}", ex);
             }
         }
 

src/Serilog.Expressions/Expressions/Compilation/Validation/ExpressionValidator.cs

@@ -15,7 +15,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using Serilog.Expressions.Compilation;
-using Serilog.Expressions.Compilation.Validation;
 using Serilog.Expressions.Parsing;
 
 // ReSharper disable MemberCanBePrivate.Global
@@ -54,8 +53,8 @@ public static CompiledExpression Compile(string expression,
     /// <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>
     /// <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>
+    /// <remarks>Validation errors including invalid regular expressions and unknown function names are returned
+    /// as friendly error messages. Invalid case-insensitive modifiers are ignored with warnings.</remarks>
     public static bool TryCompile(
         string expression,
         [MaybeNullWhen(false)] out CompiledExpression result,
@@ -76,8 +75,8 @@ public static bool TryCompile(
     /// <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>
     /// <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>
+    /// <remarks>Validation errors including invalid regular expressions and unknown function names are returned
+    /// as friendly error messages. Invalid case-insensitive modifiers are ignored with warnings.</remarks>
     public static bool TryCompile(string expression,
         IFormatProvider? formatProvider,
         NameResolver nameResolver,
@@ -102,26 +101,16 @@ static bool TryCompileImpl(string expression,
             return false;
         }
 
-        var resolver = DefaultFunctionNameResolver.Build(nameResolver);
-        
-        // Validate the expression before compilation
-        if (!ExpressionValidator.Validate(root, resolver, out var validationError))
-        {
-            result = null;
-            error = validationError ?? "Unknown validation error";
-            return false;
-        }
-
         try
         {
-            var evaluate = ExpressionCompiler.Compile(root, formatProvider, resolver);
+            var evaluate = ExpressionCompiler.Compile(root, formatProvider, DefaultFunctionNameResolver.Build(nameResolver));
             result = evt => evaluate(new(evt));
             error = null;
             return true;
         }
-        catch (ArgumentException ex)
+        catch (ExpressionValidationException ex)
         {
-            // Catch any remaining exceptions that weren't caught by validation
+            // Catch validation errors from compilation
             result = null;
             error = ex.Message;
             return false;

src/Serilog.Expressions/Expressions/SerilogExpression.cs

@@ -32,17 +32,17 @@ public void UnknownFunctionNamesAreReportedGracefully(string expression, string
     }
 
     [Theory]
-    [InlineData("Length(Name) ci", "The function `Length` does not support case-insensitive operation.")]
-    [InlineData("Round(Value, 2) ci", "The function `Round` does not support case-insensitive operation.")]
-    [InlineData("Now() ci", "The function `Now` does not support case-insensitive operation.")]
-    [InlineData("TypeOf(Value) ci", "The function `TypeOf` does not support case-insensitive operation.")]
-    [InlineData("IsDefined(Prop) ci", "The function `IsDefined` does not support case-insensitive operation.")]
-    public void InvalidCiModifierUsageIsReported(string expression, string expectedError)
+    [InlineData("Length(Name) ci")]
+    [InlineData("Round(Value, 2) ci")]
+    [InlineData("Now() ci")]
+    [InlineData("TypeOf(Value) ci")]
+    [InlineData("IsDefined(Prop) ci")]
+    public void InvalidCiModifierUsageCompilesWithWarning(string expression)
     {
         var result = SerilogExpression.TryCompile(expression, out var compiled, out var error);
-        Assert.False(result);
-        Assert.Equal(expectedError, error);
-        Assert.Null(compiled);
+        Assert.True(result, $"Failed to compile: {error}");
+        Assert.NotNull(compiled);
+        Assert.Null(error);
     }
 
     [Theory]
@@ -64,19 +64,17 @@ public void ValidCiModifierUsageCompiles(string expression)
     }
 
     [Fact]
-    public void MultipleErrorsAreCollectedAndReported()
+    public void FirstErrorIsReportedInComplexExpressions()
     {
-        var expression = "UnknownFunc() and IsMatch(Name, '[invalid') and Length(Value) ci";
+        var expression = "UnknownFunc() and Length(Value) > 5";
         var result = SerilogExpression.TryCompile(expression, out var compiled, out var error);
 
         Assert.False(result);
         Assert.Null(compiled);
 
-        // Should report all three errors
+        // Should report the first error encountered
         Assert.Contains("UnknownFunc", error);
-        Assert.Contains("Invalid regular expression", error);
-        Assert.Contains("does not support case-insensitive", error);
-        Assert.Contains("Multiple errors found", error);
+        Assert.NotNull(error);
     }
 
     [Fact]
@@ -113,8 +111,9 @@ public void CompileMethodStillThrowsForInvalidExpressions()
         Assert.Throws<ArgumentException>(() => 
             SerilogExpression.Compile("IsMatch(Name, '[invalid')"));
 
-        Assert.Throws<ArgumentException>(() => 
-            SerilogExpression.Compile("Length(Name) ci"));
+        // CI modifier on non-supporting functions compiles with warning
+        var compiledWithCi = SerilogExpression.Compile("Length(Name) ci");
+        Assert.NotNull(compiledWithCi);
 
         Assert.Throws<ArgumentException>(() => 
             SerilogExpression.Compile("IndexOfMatch(Text, '(?<')"));
@@ -148,19 +147,38 @@ public void RegexTimeoutIsRespected()
     }
 
     [Fact]
-    public void ComplexExpressionsWithMixedIssues()
+    public void ComplexExpressionsReportFirstError()
     {
-        var expression = "(UnknownFunc1() or IsMatch(Name, '(invalid')) and NotRealFunc() ci";
+        var expression = "UnknownFunc1() or Length(Value) > 5";
         var result = SerilogExpression.TryCompile(expression, out var compiled, out var error);
 
         Assert.False(result);
         Assert.Null(compiled);
         Assert.NotNull(error);
 
-        // Should report multiple errors
-        Assert.Contains("Multiple errors found", error);
+        // Should report the first error encountered during compilation
         Assert.Contains("UnknownFunc1", error);
-        Assert.Contains("NotRealFunc", error);
-        Assert.Contains("Invalid regular expression", error);
+    }
+
+    [Fact]
+    public void BackwardCompatibilityPreservedForInvalidCiUsage()
+    {
+        // These previously compiled (CI was silently ignored)
+        // They should still compile with the new changes
+        var expressions = new[]
+        {
+            "undefined() ci",
+            "null = undefined() ci",
+            "Length(Name) ci",
+            "Round(Value, 2) ci"
+        };
+
+        foreach (var expr in expressions)
+        {
+            var result = SerilogExpression.TryCompile(expr, out var compiled, out var error);
+            Assert.True(result, $"Breaking change detected: {expr} no longer compiles. Error: {error}");
+            Assert.NotNull(compiled);
+            Assert.Null(error);
+        }
     }
 }