Filters: allow has() with a condition (#986)

Bart Koelman · web-flow · commit b38736301e58 · 2021-05-17T10:36:16.000+02:00
Adds support for passing a filter condition as second argument to the has() function.
Example: GET /blogs?filter=has(posts,not(equals(url,null)))
diff --git a/docs/usage/reading/filtering.md b/docs/usage/reading/filtering.md
@@ -74,6 +74,16 @@ Putting it all together, you can build quite complex filters, such as:
 GET /blogs?include=owner.articles.revisions&filter=and(or(equals(title,'Technology'),has(owner.articles)),not(equals(owner.lastName,null)))&filter[owner.articles]=equals(caption,'Two')&filter[owner.articles.revisions]=greaterThan(publishTime,'2005-05-05') HTTP/1.1
 ```
 
+_since v4.2_
+
+The `has` function takes an optional filter condition as second parameter, for example:
+
+```http
+GET /customers?filter=has(orders,not(equals(status,'Paid'))) HTTP/1.1
+```
+
+Which returns only customers that have at least one unpaid order.
+
 # Legacy filters
 
 The next section describes how filtering worked in versions prior to v4.0. They are always applied on the set of resources being requested (no nesting).
@@ -115,7 +125,7 @@ If you want to use the new filter notation in that case, prefix the parameter va
 GET /articles?filter[caption]=tech&filter=expr:equals(caption,'cooking')) HTTP/1.1
 ```
 
-## Custom Filters
+# Custom Filters
 
 There are multiple ways you can add custom filters:
 
@@ -124,3 +134,62 @@ There are multiple ways you can add custom filters:
 3. Add an implementation of `IQueryConstraintProvider` to supply additional `FilterExpression`s, which are combined with existing filters using AND operator
 4. Override `EntityFrameworkCoreRepository.ApplyQueryLayer` to adapt the `IQueryable<T>` expression just before execution
 5. Take a deep dive and plug into reader/parser/tokenizer/visitor/builder for adding additional general-purpose filter operators
+
+# Filter syntax
+
+For reference, we provide the EBNF grammar for filter expressions below (in [ANTLR4](https://github.com/antlr/antlr4) style):
+
+```ebnf
+grammar Filter;
+
+filterExpression:
+    notExpression
+    | logicalExpression
+    | comparisonExpression
+    | matchTextExpression
+    | anyExpression
+    | hasExpression;
+
+notExpression:
+    'not' LPAREN filterExpression RPAREN;
+
+logicalExpression:
+    ( 'and' | 'or' ) LPAREN filterExpression ( COMMA filterExpression )* RPAREN;
+
+comparisonExpression:
+    ( 'equals' | 'greaterThan' | 'greaterOrEqual' | 'lessThan' | 'lessOrEqual' ) LPAREN (
+        countExpression | fieldChain
+    ) COMMA (
+        countExpression | literalConstant | 'null' | fieldChain
+    ) RPAREN;
+
+matchTextExpression:
+    ( 'contains' | 'startsWith' | 'endsWith' ) LPAREN fieldChain COMMA literalConstant RPAREN;
+
+anyExpression:
+    'any' LPAREN fieldChain COMMA literalConstant ( COMMA literalConstant )+ RPAREN;
+
+hasExpression:
+    'has' LPAREN fieldChain ( COMMA filterExpression )? RPAREN;
+
+countExpression:
+    'count' LPAREN fieldChain RPAREN;
+
+fieldChain:
+    FIELD ( '.' FIELD )*;
+
+literalConstant:
+    ESCAPED_TEXT;
+
+LPAREN: '(';
+RPAREN: ')';
+COMMA: ',';
+
+fragment OUTER_FIELD_CHARACTER: [A-Za-z0-9];
+fragment INNER_FIELD_CHARACTER: [A-Za-z0-9_-];
+FIELD: OUTER_FIELD_CHARACTER ( INNER_FIELD_CHARACTER* OUTER_FIELD_CHARACTER )?;
+
+ESCAPED_TEXT: '\'' ( ~['] | '\'\'' )* '\'' ;
+
+LINE_BREAKS: [\r\n]+ -> skip;
+```
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/CollectionNotEmptyExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/CollectionNotEmptyExpression.cs
@@ -1,21 +1,25 @@
+using System;
+using System.Text;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Queries.Internal.Parsing;
 
 namespace JsonApiDotNetCore.Queries.Expressions
 {
     /// <summary>
-    /// Represents the "has" filter function, resulting from text such as: has(articles)
+    /// Represents the "has" filter function, resulting from text such as: has(articles) or has(articles,equals(isHidden,'false'))
     /// </summary>
     [PublicAPI]
     public class CollectionNotEmptyExpression : FilterExpression
     {
         public ResourceFieldChainExpression TargetCollection { get; }
+        public FilterExpression Filter { get; }
 
-        public CollectionNotEmptyExpression(ResourceFieldChainExpression targetCollection)
+        public CollectionNotEmptyExpression(ResourceFieldChainExpression targetCollection, FilterExpression filter)
         {
             ArgumentGuard.NotNull(targetCollection, nameof(targetCollection));
 
             TargetCollection = targetCollection;
+            Filter = filter;
         }
 
         public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgument, TResult> visitor, TArgument argument)
@@ -25,7 +29,20 @@ public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgum
 
         public override string ToString()
         {
-            return $"{Keywords.Has}({TargetCollection})";
+            var builder = new StringBuilder();
+            builder.Append(Keywords.Has);
+            builder.Append('(');
+            builder.Append(TargetCollection);
+
+            if (Filter != null)
+            {
+                builder.Append(',');
+                builder.Append(Filter);
+            }
+
+            builder.Append(')');
+
+            return builder.ToString();
         }
 
         public override bool Equals(object obj)
@@ -42,12 +59,12 @@ public override bool Equals(object obj)
 
             var other = (CollectionNotEmptyExpression)obj;
 
-            return TargetCollection.Equals(other.TargetCollection);
+            return TargetCollection.Equals(other.TargetCollection) && Equals(Filter, other.Filter);
         }
 
         public override int GetHashCode()
         {
-            return TargetCollection.GetHashCode();
+            return HashCode.Combine(TargetCollection, Filter);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/FilterExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/FilterExpression.cs
@@ -1,7 +1,7 @@
 namespace JsonApiDotNetCore.Queries.Expressions
 {
     /// <summary>
-    /// Represents the base type for filter functions.
+    /// Represents the base type for filter functions that return a boolean value.
     /// </summary>
     public abstract class FilterExpression : FunctionExpression
     {
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/FunctionExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/FunctionExpression.cs
@@ -1,7 +1,7 @@
 namespace JsonApiDotNetCore.Queries.Expressions
 {
     /// <summary>
-    /// Represents the base type for functions.
+    /// Represents the base type for functions that return a value.
     /// </summary>
     public abstract class FunctionExpression : QueryExpression
     {
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/LogicalExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/LogicalExpression.cs
@@ -14,9 +14,9 @@ namespace JsonApiDotNetCore.Queries.Expressions
     public class LogicalExpression : FilterExpression
     {
         public LogicalOperator Operator { get; }
-        public IReadOnlyCollection<QueryExpression> Terms { get; }
+        public IReadOnlyCollection<FilterExpression> Terms { get; }
 
-        public LogicalExpression(LogicalOperator @operator, IReadOnlyCollection<QueryExpression> terms)
+        public LogicalExpression(LogicalOperator @operator, IReadOnlyCollection<FilterExpression> terms)
         {
             ArgumentGuard.NotNull(terms, nameof(terms));
 
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/NotExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/NotExpression.cs
@@ -9,9 +9,9 @@ namespace JsonApiDotNetCore.Queries.Expressions
     [PublicAPI]
     public class NotExpression : FilterExpression
     {
-        public QueryExpression Child { get; }
+        public FilterExpression Child { get; }
 
-        public NotExpression(QueryExpression child)
+        public NotExpression(FilterExpression child)
         {
             ArgumentGuard.NotNull(child, nameof(child));
 
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs b/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs
@@ -54,7 +54,7 @@ public override QueryExpression VisitLogical(LogicalExpression expression, TArgu
         {
             if (expression != null)
             {
-                IReadOnlyCollection<QueryExpression> newTerms = VisitSequence(expression.Terms, argument);
+                IReadOnlyCollection<FilterExpression> newTerms = VisitSequence(expression.Terms, argument);
 
                 if (newTerms.Count == 1)
                 {
@@ -75,9 +75,7 @@ public override QueryExpression VisitNot(NotExpression expression, TArgument arg
         {
             if (expression != null)
             {
-                QueryExpression newChild = Visit(expression.Child, argument);
-
-                if (newChild != null)
+                if (Visit(expression.Child, argument) is FilterExpression newChild)
                 {
                     var newExpression = new NotExpression(newChild);
                     return newExpression.Equals(expression) ? expression : newExpression;
@@ -93,7 +91,9 @@ public override QueryExpression VisitCollectionNotEmpty(CollectionNotEmptyExpres
             {
                 if (Visit(expression.TargetCollection, argument) is ResourceFieldChainExpression newTargetCollection)
                 {
-                    var newExpression = new CollectionNotEmptyExpression(newTargetCollection);
+                    FilterExpression newFilter = expression.Filter != null ? Visit(expression.Filter, argument) as FilterExpression : null;
+
+                    var newExpression = new CollectionNotEmptyExpression(newTargetCollection, newFilter);
                     return newExpression.Equals(expression) ? expression : newExpression;
                 }
             }
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/FilterParser.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/FilterParser.cs
@@ -14,6 +14,7 @@ namespace JsonApiDotNetCore.Queries.Internal.Parsing
     [PublicAPI]
     public class FilterParser : QueryExpressionParser
     {
+        private readonly IResourceContextProvider _resourceContextProvider;
         private readonly IResourceFactory _resourceFactory;
         private readonly Action<ResourceFieldAttribute, ResourceContext, string> _validateSingleFieldCallback;
         private ResourceContext _resourceContextInScope;
@@ -22,8 +23,10 @@ public FilterParser(IResourceContextProvider resourceContextProvider, IResourceF
             Action<ResourceFieldAttribute, ResourceContext, string> validateSingleFieldCallback = null)
             : base(resourceContextProvider)
         {
+            ArgumentGuard.NotNull(resourceContextProvider, nameof(resourceContextProvider));
             ArgumentGuard.NotNull(resourceFactory, nameof(resourceFactory));
 
+            _resourceContextProvider = resourceContextProvider;
             _resourceFactory = resourceFactory;
             _validateSingleFieldCallback = validateSingleFieldCallback;
         }
@@ -103,7 +106,7 @@ protected LogicalExpression ParseLogical(string operatorName)
             EatText(operatorName);
             EatSingleCharacterToken(TokenKind.OpenParen);
 
-            var terms = new List<QueryExpression>();
+            var terms = new List<FilterExpression>();
 
             FilterExpression term = ParseFilter();
             terms.Add(term);
@@ -234,10 +237,31 @@ protected CollectionNotEmptyExpression ParseHas()
             EatSingleCharacterToken(TokenKind.OpenParen);
 
             ResourceFieldChainExpression targetCollection = ParseFieldChain(FieldChainRequirements.EndsInToMany, null);
+            FilterExpression filter = null;
+
+            if (TokenStack.TryPeek(out Token nextToken) && nextToken.Kind == TokenKind.Comma)
+            {
+                EatSingleCharacterToken(TokenKind.Comma);
+
+                filter = ParseFilterInHas((HasManyAttribute)targetCollection.Fields.Last());
+            }
 
             EatSingleCharacterToken(TokenKind.CloseParen);
 
-            return new CollectionNotEmptyExpression(targetCollection);
+            return new CollectionNotEmptyExpression(targetCollection, filter);
+        }
+
+        private FilterExpression ParseFilterInHas(HasManyAttribute hasManyRelationship)
+        {
+            ResourceContext outerScopeBackup = _resourceContextInScope;
+
+            Type innerResourceType = hasManyRelationship.RightType;
+            _resourceContextInScope = _resourceContextProvider.GetResourceContext(innerResourceType);
+
+            FilterExpression filter = ParseFilter();
+
+            _resourceContextInScope = outerScopeBackup;
+            return filter;
         }
 
         protected QueryExpression ParseCountOrField(FieldChainRequirements chainRequirements)
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryableBuilder.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryableBuilder.cs
@@ -93,7 +93,7 @@ protected virtual Expression ApplyFilter(Expression source, FilterExpression fil
         {
             using LambdaScope lambdaScope = _lambdaScopeFactory.CreateScope(_elementType);
 
-            var builder = new WhereClauseBuilder(source, lambdaScope, _extensionType);
+            var builder = new WhereClauseBuilder(source, lambdaScope, _extensionType, _nameFactory);
             return builder.ApplyWhere(filter);
         }
 
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/WhereClauseBuilder.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/WhereClauseBuilder.cs
@@ -23,27 +23,35 @@ public class WhereClauseBuilder : QueryClauseBuilder<Type>
 
         private readonly Expression _source;
         private readonly Type _extensionType;
+        private readonly LambdaParameterNameFactory _nameFactory;
 
-        public WhereClauseBuilder(Expression source, LambdaScope lambdaScope, Type extensionType)
+        public WhereClauseBuilder(Expression source, LambdaScope lambdaScope, Type extensionType, LambdaParameterNameFactory nameFactory)
             : base(lambdaScope)
         {
             ArgumentGuard.NotNull(source, nameof(source));
             ArgumentGuard.NotNull(extensionType, nameof(extensionType));
+            ArgumentGuard.NotNull(nameFactory, nameof(nameFactory));
 
             _source = source;
             _extensionType = extensionType;
+            _nameFactory = nameFactory;
         }
 
         public Expression ApplyWhere(FilterExpression filter)
         {
             ArgumentGuard.NotNull(filter, nameof(filter));
 
-            Expression body = Visit(filter, null);
-            LambdaExpression lambda = Expression.Lambda(body, LambdaScope.Parameter);
+            LambdaExpression lambda = GetPredicateLambda(filter);
 
             return WhereExtensionMethodCall(lambda);
         }
 
+        private LambdaExpression GetPredicateLambda(FilterExpression filter)
+        {
+            Expression body = Visit(filter, null);
+            return Expression.Lambda(body, LambdaScope.Parameter);
+        }
+
         private Expression WhereExtensionMethodCall(LambdaExpression predicate)
         {
             return Expression.Call(_extensionType, "Where", LambdaScope.Parameter.Type.AsArray(), _source, predicate);
@@ -60,11 +68,28 @@ public override Expression VisitCollectionNotEmpty(CollectionNotEmptyExpression
                 throw new InvalidOperationException("Expression must be a collection.");
             }
 
-            return AnyExtensionMethodCall(elementType, property);
+            Expression predicate = null;
+
+            if (expression.Filter != null)
+            {
+                var hasManyThrough = expression.TargetCollection.Fields.Last() as HasManyThroughAttribute;
+                var lambdaScopeFactory = new LambdaScopeFactory(_nameFactory, hasManyThrough);
+                using LambdaScope lambdaScope = lambdaScopeFactory.CreateScope(elementType);
+
+                var builder = new WhereClauseBuilder(property, lambdaScope, typeof(Enumerable), _nameFactory);
+                predicate = builder.GetPredicateLambda(expression.Filter);
+            }
+
+            return AnyExtensionMethodCall(elementType, property, predicate);
         }
 
-        private static MethodCallExpression AnyExtensionMethodCall(Type elementType, Expression source)
+        private static MethodCallExpression AnyExtensionMethodCall(Type elementType, Expression source, Expression predicate)
         {
+            if (predicate != null)
+            {
+                return Expression.Call(typeof(Enumerable), "Any", elementType.AsArray(), source, predicate);
+            }
+
             return Expression.Call(typeof(Enumerable), "Any", elementType.AsArray(), source);
         }
 
@@ -276,7 +301,6 @@ protected override MemberExpression CreatePropertyExpressionForFieldChain(IReadO
 
         private static string GetPropertyName(ResourceFieldAttribute field)
         {
-            // In case of a HasManyThrough access (from count() or has() function), we only need to look at the number of entries in the join table.
             return field is HasManyThroughAttribute hasManyThrough ? hasManyThrough.ThroughProperty.Name : field.Property.Name;
         }
     }
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/CompositeKeys/CarExpressionRewriter.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/CompositeKeys/CarExpressionRewriter.cs
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/QueryStrings/Filtering/FilterDepthTests.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/QueryStrings/Filtering/FilterDepthTests.cs
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/QueryStrings/Filtering/FilterOperatorTests.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/QueryStrings/Filtering/FilterOperatorTests.cs
diff --git a/test/JsonApiDotNetCoreExampleTests/UnitTests/QueryStringParameters/FilterParseTests.cs b/test/JsonApiDotNetCoreExampleTests/UnitTests/QueryStringParameters/FilterParseTests.cs

Original file line number	Diff line number	Diff line change
`@@ -1,21 +1,25 @@`
	`1`	`+using System;`
	`2`	`+using System.Text;`
`1`	`3`	`using JetBrains.Annotations;`
`2`	`4`	`using JsonApiDotNetCore.Queries.Internal.Parsing;`
`3`	`5`
`4`	`6`	`namespace JsonApiDotNetCore.Queries.Expressions`
`5`	`7`	`{`
`6`	`8`	`/// <summary>`
`7`		`- /// Represents the "has" filter function, resulting from text such as: has(articles)`
	`9`	`+ /// Represents the "has" filter function, resulting from text such as: has(articles) or has(articles,equals(isHidden,'false'))`
`8`	`10`	`/// </summary>`
`9`	`11`	`[PublicAPI]`
`10`	`12`	`public class CollectionNotEmptyExpression : FilterExpression`
`11`	`13`	`{`
`12`	`14`	`public ResourceFieldChainExpression TargetCollection { get; }`
	`15`	`+ public FilterExpression Filter { get; }`
`13`	`16`
`14`		`- public CollectionNotEmptyExpression(ResourceFieldChainExpression targetCollection)`
	`17`	`+ public CollectionNotEmptyExpression(ResourceFieldChainExpression targetCollection, FilterExpression filter)`
`15`	`18`	`{`
`16`	`19`	`ArgumentGuard.NotNull(targetCollection, nameof(targetCollection));`
`17`	`20`
`18`	`21`	`TargetCollection = targetCollection;`
	`22`	`+ Filter = filter;`
`19`	`23`	`}`
`20`	`24`
`21`	`25`	`public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgument, TResult> visitor, TArgument argument)`
`@@ -25,7 +29,20 @@ public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgum`
`25`	`29`
`26`	`30`	`public override string ToString()`
`27`	`31`	`{`
`28`		`- return $"{Keywords.Has}({TargetCollection})";`
	`32`	`+ var builder = new StringBuilder();`
	`33`	`+ builder.Append(Keywords.Has);`
	`34`	`+ builder.Append('(');`
	`35`	`+ builder.Append(TargetCollection);`
	`36`	`+`
	`37`	`+ if (Filter != null)`
	`38`	`+ {`
	`39`	`+ builder.Append(',');`
	`40`	`+ builder.Append(Filter);`
	`41`	`+ }`
	`42`	`+`
	`43`	`+ builder.Append(')');`
	`44`	`+`
	`45`	`+ return builder.ToString();`
`29`	`46`	`}`
`30`	`47`
`31`	`48`	`public override bool Equals(object obj)`
`@@ -42,12 +59,12 @@ public override bool Equals(object obj)`
`42`	`59`
`43`	`60`	`var other = (CollectionNotEmptyExpression)obj;`
`44`	`61`
`45`		`- return TargetCollection.Equals(other.TargetCollection);`
	`62`	`+ return TargetCollection.Equals(other.TargetCollection) && Equals(Filter, other.Filter);`
`46`	`63`	`}`
`47`	`64`
`48`	`65`	`public override int GetHashCode()`
`49`	`66`	`{`
`50`		`- return TargetCollection.GetHashCode();`
	`67`	`+ return HashCode.Combine(TargetCollection, Filter);`
`51`	`68`	`}`
`52`	`69`	`}`
`53`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`namespace JsonApiDotNetCore.Queries.Expressions`
`2`	`2`	`{`
`3`	`3`	`/// <summary>`
`4`		`- /// Represents the base type for filter functions.`
	`4`	`+ /// Represents the base type for filter functions that return a boolean value.`
`5`	`5`	`/// </summary>`
`6`	`6`	`public abstract class FilterExpression : FunctionExpression`
`7`	`7`	`{`
Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,9 @@ namespace JsonApiDotNetCore.Queries.Expressions`
`14`	`14`	`public class LogicalExpression : FilterExpression`
`15`	`15`	`{`
`16`	`16`	`public LogicalOperator Operator { get; }`
`17`		`- public IReadOnlyCollection<QueryExpression> Terms { get; }`
	`17`	`+ public IReadOnlyCollection<FilterExpression> Terms { get; }`
`18`	`18`
`19`		`- public LogicalExpression(LogicalOperator @operator, IReadOnlyCollection<QueryExpression> terms)`
	`19`	`+ public LogicalExpression(LogicalOperator @operator, IReadOnlyCollection<FilterExpression> terms)`
`20`	`20`	`{`
`21`	`21`	`ArgumentGuard.NotNull(terms, nameof(terms));`
`22`	`22`
Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,9 @@ namespace JsonApiDotNetCore.Queries.Expressions`
`9`	`9`	`[PublicAPI]`
`10`	`10`	`public class NotExpression : FilterExpression`
`11`	`11`	`{`
`12`		`- public QueryExpression Child { get; }`
	`12`	`+ public FilterExpression Child { get; }`
`13`	`13`
`14`		`- public NotExpression(QueryExpression child)`
	`14`	`+ public NotExpression(FilterExpression child)`
`15`	`15`	`{`
`16`	`16`	`ArgumentGuard.NotNull(child, nameof(child));`
`17`	`17`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ public override QueryExpression VisitLogical(LogicalExpression expression, TArgu`
`54`	`54`	`{`
`55`	`55`	`if (expression != null)`
`56`	`56`	`{`
`57`		`- IReadOnlyCollection<QueryExpression> newTerms = VisitSequence(expression.Terms, argument);`
	`57`	`+ IReadOnlyCollection<FilterExpression> newTerms = VisitSequence(expression.Terms, argument);`
`58`	`58`
`59`	`59`	`if (newTerms.Count == 1)`
`60`	`60`	`{`
`@@ -75,9 +75,7 @@ public override QueryExpression VisitNot(NotExpression expression, TArgument arg`
`75`	`75`	`{`
`76`	`76`	`if (expression != null)`
`77`	`77`	`{`
`78`		`- QueryExpression newChild = Visit(expression.Child, argument);`
`79`		`-`
`80`		`- if (newChild != null)`
	`78`	`+ if (Visit(expression.Child, argument) is FilterExpression newChild)`
`81`	`79`	`{`
`82`	`80`	`var newExpression = new NotExpression(newChild);`
`83`	`81`	`return newExpression.Equals(expression) ? expression : newExpression;`
`@@ -93,7 +91,9 @@ public override QueryExpression VisitCollectionNotEmpty(CollectionNotEmptyExpres`
`93`	`91`	`{`
`94`	`92`	`if (Visit(expression.TargetCollection, argument) is ResourceFieldChainExpression newTargetCollection)`
`95`	`93`	`{`
`96`		`- var newExpression = new CollectionNotEmptyExpression(newTargetCollection);`
	`94`	`+ FilterExpression newFilter = expression.Filter != null ? Visit(expression.Filter, argument) as FilterExpression : null;`
	`95`	`+`
	`96`	`+ var newExpression = new CollectionNotEmptyExpression(newTargetCollection, newFilter);`
`97`	`97`	`return newExpression.Equals(expression) ? expression : newExpression;`
`98`	`98`	`}`
`99`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ protected virtual Expression ApplyFilter(Expression source, FilterExpression fil`
`93`	`93`	`{`
`94`	`94`	`using LambdaScope lambdaScope = _lambdaScopeFactory.CreateScope(_elementType);`
`95`	`95`
`96`		`- var builder = new WhereClauseBuilder(source, lambdaScope, _extensionType);`
	`96`	`+ var builder = new WhereClauseBuilder(source, lambdaScope, _extensionType, _nameFactory);`
`97`	`97`	`return builder.ApplyWhere(filter);`
`98`	`98`	`}`
`99`	`99`