Move some silliness around is null to the parser

nblumhardt · nblumhardt · commit 29f45f49041e · 2020-09-14T08:37:59.000+10:00
diff --git a/README.md b/README.md
@@ -1,7 +1,7 @@
-# _Serilog.Expressions_
+# _Serilog Expressions_
 
 An embeddable mini-language for filtering, enriching, and formatting Serilog 
-events, ideal for use in JSON or XML configuration.
+events, ideal for use with JSON or XML configuration.
 
 ## Getting started
 
diff --git a/src/Serilog.Expressions/Expressions/Compilation/ExpressionCompiler.cs b/src/Serilog.Expressions/Expressions/Compilation/ExpressionCompiler.cs
@@ -1,7 +1,5 @@
 ﻿using Serilog.Expressions.Ast;
 using Serilog.Expressions.Compilation.Arrays;
-using Serilog.Expressions.Compilation.In;
-using Serilog.Expressions.Compilation.Is;
 using Serilog.Expressions.Compilation.Linq;
 using Serilog.Expressions.Compilation.Properties;
 using Serilog.Expressions.Compilation.Text;
@@ -20,9 +18,7 @@ public static CompiledExpression Compile(Expression expression)
             actual = LikeSyntaxTransformer.Rewrite(actual);
             actual = PropertiesObjectAccessorTransformer.Rewrite(actual);
             actual = ConstantArrayEvaluator.Evaluate(actual);
-            actual = NotInRewriter.Rewrite(actual); 
             actual = WildcardComprehensionTransformer.Expand(actual);
-            actual = IsOperatorTransformer.Rewrite(actual);
 
             return LinqExpressionCompiler.Compile(actual);
         }
diff --git a/src/Serilog.Expressions/Expressions/Compilation/In/NotInRewriter.cs b/src/Serilog.Expressions/Expressions/Compilation/In/NotInRewriter.cs
diff --git a/src/Serilog.Expressions/Expressions/Compilation/Is/IsOperatorTransformer.cs b/src/Serilog.Expressions/Expressions/Compilation/Is/IsOperatorTransformer.cs
diff --git a/src/Serilog.Expressions/Expressions/Compilation/Text/LikeSyntaxTransformer.cs b/src/Serilog.Expressions/Expressions/Compilation/Text/LikeSyntaxTransformer.cs
@@ -21,10 +21,10 @@ protected override Expression Transform(CallExpression lx)
             if (lx.Operands.Length != 2)
                 return base.Transform(lx);
 
-            if (Operators.SameOperator(lx.OperatorName, Operators.IntermediateOpSqlLike))
+            if (Operators.SameOperator(lx.OperatorName, Operators.IntermediateOpLike))
                 return TryCompileLikeExpression(lx.Operands[0], lx.Operands[1]);
             
-            if (Operators.SameOperator(lx.OperatorName, Operators.IntermediateOpSqlNotLike))
+            if (Operators.SameOperator(lx.OperatorName, Operators.IntermediateOpNotLike))
                 return new CallExpression(
                     Operators.RuntimeOpStrictNot,
                     TryCompileLikeExpression(lx.Operands[0], lx.Operands[1]));
diff --git a/src/Serilog.Expressions/Expressions/Operators.cs b/src/Serilog.Expressions/Expressions/Operators.cs
@@ -48,11 +48,10 @@ static class Operators
         public const string RuntimeOpIsNull = "_Internal_IsNull";
         public const string RuntimeOpIsNotNull = "_Internal_IsNotNull";
         public const string OpCoalesce = "Coalesce";
-        public const string IntermediateOpSqlLike = "_Internal_Like";
-        public const string IntermediateOpSqlNotLike = "_Internal_NotLike";
-        public const string IntermediateOpSqlIs = "_Internal_Is";
-        public const string RuntimeOpSqlIn = "_Internal_In";
-        public const string IntermediateOpSqlNotIn = "_Internal_NotIn";
+        public const string IntermediateOpLike = "_Internal_Like";
+        public const string IntermediateOpNotLike = "_Internal_NotLike";
+        public const string RuntimeOpIn = "_Internal_In";
+        public const string RuntimeOpNotIn = "_Internal_NotIn";
         public const string RuntimeOpStrictNot = "_Internal_StrictNot";
         public const string OpSubstring = "Substring";
         public const string OpIndexOfMatch = "IndexOfMatch";
@@ -70,11 +69,9 @@ static class Operators
             OpLessThanOrEqual,
             OpGreaterThan,
             OpGreaterThanOrEqual,
-            IntermediateOpSqlLike,
-            IntermediateOpSqlNotLike,
-            RuntimeOpSqlIn,
-            IntermediateOpSqlNotIn,
-            IntermediateOpSqlIs
+            IntermediateOpLike,
+            IntermediateOpNotLike,
+            RuntimeOpIn,
         };
 
         public static bool SameOperator(string op1, string op2)
diff --git a/src/Serilog.Expressions/Expressions/Parsing/ExpressionTokenParsers.cs b/src/Serilog.Expressions/Expressions/Parsing/ExpressionTokenParsers.cs
@@ -40,11 +40,31 @@ public static TokenListParserResult<ExpressionToken, Expression> TryPartialParse
         static readonly TokenListParser<ExpressionToken, string> Neq = Token.EqualTo(ExpressionToken.NotEqual).Value(Operators.OpNotEqual);
         static readonly TokenListParser<ExpressionToken, string> Negate = Token.EqualTo(ExpressionToken.Minus).Value(Operators.OpNegate);
         static readonly TokenListParser<ExpressionToken, string> Not = Token.EqualTo(ExpressionToken.Not).Value(Operators.OpNot);
-        static readonly TokenListParser<ExpressionToken, string> Like = Token.EqualTo(ExpressionToken.Like).Value(Operators.IntermediateOpSqlLike);
-        static readonly TokenListParser<ExpressionToken, string> NotLike = Not.IgnoreThen(Like).Value(Operators.IntermediateOpSqlNotLike);
-        static readonly TokenListParser<ExpressionToken, string> In = Token.EqualTo(ExpressionToken.In).Value(Operators.RuntimeOpSqlIn);
-        static readonly TokenListParser<ExpressionToken, string> NotIn = Not.IgnoreThen(In).Value(Operators.IntermediateOpSqlNotIn);
-        static readonly TokenListParser<ExpressionToken, string> Is = Token.EqualTo(ExpressionToken.Is).Value(Operators.IntermediateOpSqlIs);
+        
+        static readonly TokenListParser<ExpressionToken, string> Like = Token.EqualTo(ExpressionToken.Like).Value(Operators.IntermediateOpLike);
+
+        static readonly TokenListParser<ExpressionToken, string> NotLike =
+            Token.EqualTo(ExpressionToken.Not)
+                .IgnoreThen(Token.EqualTo(ExpressionToken.Like))
+                .Value(Operators.IntermediateOpNotLike);
+        
+        static readonly TokenListParser<ExpressionToken, string> In = Token.EqualTo(ExpressionToken.In).Value(Operators.RuntimeOpIn);
+
+        static readonly TokenListParser<ExpressionToken, string> NotIn = 
+            Token.EqualTo(ExpressionToken.Not)
+                .IgnoreThen(Token.EqualTo(ExpressionToken.In))
+                .Value(Operators.RuntimeOpNotIn);
+
+        static readonly TokenListParser<ExpressionToken, string> IsNull = 
+            Token.EqualTo(ExpressionToken.Is)
+                .IgnoreThen(Token.EqualTo(ExpressionToken.Null))
+                .Value(Operators.RuntimeOpIsNull);
+        
+        static readonly TokenListParser<ExpressionToken, string> IsNotNull = 
+            Token.EqualTo(ExpressionToken.Is)
+                .IgnoreThen(Token.EqualTo(ExpressionToken.Not))
+                .IgnoreThen(Token.EqualTo(ExpressionToken.Null))
+                .Value(Operators.RuntimeOpIsNotNull);
 
         static readonly TokenListParser<ExpressionToken, Func<Expression, Expression>> PropertyPathStep =
             Token.EqualTo(ExpressionToken.Period)
@@ -152,15 +172,28 @@ from path in PropertyPathStep.Or(PropertyPathIndexerStep).Many()
         static readonly TokenListParser<ExpressionToken, Expression> Operand =
             (from op in Negate.Or(Not)
                 from path in Path
-                select MakeUnary(op, path)).Or(Path).Named("expression");
+                select MakeUnary(op, path))
+            .Or(Path)
+            .Then(operand => Token.EqualTo(ExpressionToken.Is).Try()
+                .IgnoreThen(
+                    Token.EqualTo(ExpressionToken.Null).Value(Operators.RuntimeOpIsNull)
+                        .Or(Token.EqualTo(ExpressionToken.Not).IgnoreThen(Token.EqualTo(ExpressionToken.Null)).Value(Operators.RuntimeOpIsNotNull)))
+                .Select(op => (Expression)new CallExpression(op, operand))
+                .OptionalOrDefault(operand))
+            .Named("expression");
 
         static readonly TokenListParser<ExpressionToken, Expression> InnerTerm = Parse.Chain(Power, Operand, MakeBinary);
 
         static readonly TokenListParser<ExpressionToken, Expression> Term = Parse.Chain(Multiply.Or(Divide).Or(Modulo), InnerTerm, MakeBinary);
 
         static readonly TokenListParser<ExpressionToken, Expression> Comparand = Parse.Chain(Add.Or(Subtract), Term, MakeBinary);
 
-        static readonly TokenListParser<ExpressionToken, Expression> Comparison = Parse.Chain(Is.Or(NotLike.Try().Or(Like)).Or(NotIn.Try().Or(In)).Or(Lte.Or(Neq).Or(Lt)).Or(Gte.Or(Gt)).Or(Eq), Comparand, MakeBinary);
+        static readonly TokenListParser<ExpressionToken, Expression> Comparison = Parse.Chain(
+            NotLike.Try().Or(Like)
+                .Or(NotIn.Try().Or(In))
+                .Or(Lte.Or(Neq).Or(Lt))
+                .Or(Gte.Or(Gt))
+                .Or(Eq), Comparand, MakeBinary);
 
         static readonly TokenListParser<ExpressionToken, Expression> Conjunction = Parse.Chain(And, Comparison, MakeBinary);
 
diff --git a/src/Serilog.Expressions/Expressions/Runtime/RuntimeOperators.cs b/src/Serilog.Expressions/Expressions/Runtime/RuntimeOperators.cs
@@ -196,6 +196,11 @@ static bool UnboxedEqualHelper(LogEventPropertyValue? left, LogEventPropertyValu
             return null;
         }
 
+        public static LogEventPropertyValue? _Internal_NotIn(LogEventPropertyValue? item, LogEventPropertyValue? collection)
+        {
+            return _Internal_StrictNot(_Internal_In(item, collection));
+        }
+        
         public static LogEventPropertyValue? NotEqual(LogEventPropertyValue? left, LogEventPropertyValue? right)
         {
             if (left == null || right == null)
diff --git a/src/Serilog.Expressions/Serilog.Expressions.csproj b/src/Serilog.Expressions/Serilog.Expressions.csproj
@@ -1,13 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <Description>Expression evaluation over Serilog events.</Description>
+    <Description>An embeddable mini-language for filtering, enriching, and formatting Serilog
+      events, ideal for use with JSON or XML configuration.</Description>
     <VersionPrefix>1.0.0</VersionPrefix>
     <Authors>Serilog Contributors</Authors>
     <TargetFramework>netstandard2.1</TargetFramework>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <AssemblyName>Serilog.Expressions</AssemblyName>
     <RootNamespace>Serilog</RootNamespace>
     <AssemblyOriginatorKeyFile>../../assets/Serilog.snk</AssemblyOriginatorKeyFile>
     <SignAssembly>true</SignAssembly>
@@ -23,7 +23,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Serilog" Version="2.9.0" />
+    <PackageReference Include="Serilog" Version="2.10.0" />
     <PackageReference Include="Superpower" Version="2.3.0" />
   </ItemGroup>
 
diff --git a/test/Serilog.Expressions.Tests/Cases/expression-evaluation-cases.asv b/test/Serilog.Expressions.Tests/Cases/expression-evaluation-cases.asv
@@ -160,6 +160,21 @@ null >= null                         ⇶ undefined
 undefined >= null                    ⇶ undefined
 undefined >= undefined               ⇶ undefined
 
+// Comparators - in/not in
+1 in [1, 2, 3]                       ⇶ true
+5 in [1, 2, 3]                       ⇶ false
+1 not in [1, 2, 3]                   ⇶ false
+5 not in [1, 2, 3]                   ⇶ true
+undefined in [1, 2, 3]               ⇶ undefined
+undefined not in [1, 2, 3]           ⇶ undefined
+1 in undefined                       ⇶ undefined
+null in [1, null, 3]                 ⇶ true
+
+// Comparators - is null/is not null
+null is null                         ⇶ true
+null is not null                     ⇶ false
+undefined is null                    ⇶ true
+
 // Property names and accessors
 [5, 6, 7][1]                         ⇶ 6
 User.Name                            ⇶ 'nblumhardt'
diff --git a/test/Serilog.Expressions.Tests/ExpressionEvaluationTests.cs b/test/Serilog.Expressions.Tests/ExpressionEvaluationTests.cs
@@ -24,7 +24,7 @@ static IEnumerable<object[]> ReadCases(string filename)
         }
 
         public static IEnumerable<object[]> EphemeralExpressionEvaluationCases =>
-            ReadCases("ephemeral-expression-evaluation-cases.asv");
+            ReadCases("expression-evaluation-cases.asv");
 
         [Theory]
         [MemberData(nameof(EphemeralExpressionEvaluationCases))]
diff --git a/test/Serilog.Expressions.Tests/ExpressionParserTests.cs b/test/Serilog.Expressions.Tests/ExpressionParserTests.cs
@@ -30,14 +30,15 @@ public class ExpressionParserTests
         [InlineData("equal(AProperty[ * ].Description, 1)", "equal(AProperty[*].Description, 1)")]
         [InlineData("AProperty like '%foo'", "_Internal_Like(AProperty, '%foo')")]
         [InlineData("AProperty not like '%foo'", "_Internal_NotLike(AProperty, '%foo')")]
-        [InlineData("A is null", "_Internal_Is(A, null)")]
-        [InlineData("A IS NOT NULL", "_Internal_Is(A, Not(null))")]
-        [InlineData("A is not null or B", "Or(_Internal_Is(A, Not(null)), B)")]
+        [InlineData("A is null", "_Internal_IsNull(A)")]
+        [InlineData("A IS NOT NULL", "_Internal_IsNotNull(A)")]
+        [InlineData("A is not null or B", "Or(_Internal_IsNotNull(A), B)")]
         [InlineData("@EventType = 0xC0ffee", "Equal(@EventType, 12648430)")]
         [InlineData("@Level in ['Error', 'Warning']", "_Internal_In(@Level, ['Error', 'Warning'])")]
         [InlineData("5 not in [1, 2]", "_Internal_NotIn(5, [1, 2])")]
         [InlineData("1+1", "Add(1, 1)")]
         [InlineData("'te\nst'", null)]
+        [InlineData("A.B is null", "_Internal_IsNull(A.B)")]
         public void ValidSyntaxIsAccepted(string input, string? expected = null)
         {
             var roundTrip = ExpressionParser.Parse(input).ToString();

Original file line number	Diff line number	Diff line change
`@@ -196,6 +196,11 @@ static bool UnboxedEqualHelper(LogEventPropertyValue? left, LogEventPropertyValu`
`196`	`196`	`return null;`
`197`	`197`	`}`
`198`	`198`
	`199`	`+ public static LogEventPropertyValue? _Internal_NotIn(LogEventPropertyValue? item, LogEventPropertyValue? collection)`
	`200`	`+ {`
	`201`	`+ return _Internal_StrictNot(_Internal_In(item, collection));`
	`202`	`+ }`
	`203`	`+`
`199`	`204`	`public static LogEventPropertyValue? NotEqual(LogEventPropertyValue? left, LogEventPropertyValue? right)`
`200`	`205`	`{`
`201`	`206`	`if (left == null \|\| right == null)`