CSHARP-4691: Support GetType comparison in LINQ3.

rstam · rstam · commit a24f1cdb44ed · 2023-06-29T14:13:25.000-07:00
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Expressions/AstExpression.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Expressions/AstExpression.cs
@@ -453,6 +453,11 @@ public static AstExpression IndexOfCP(AstExpression @string, AstExpression value
             return new AstIndexOfCPExpression(@string, value, start, end);
         }
 
+        public static AstExpression IsArray(AstExpression value)
+        {
+            return new AstUnaryExpression(AstUnaryOperator.IsArray, value);
+        }
+
         public static AstExpression Last(AstExpression array)
         {
             return new AstUnaryExpression(AstUnaryOperator.Last, array);
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Filters/AstFilter.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Filters/AstFilter.cs
@@ -195,6 +195,11 @@ public static AstFilter Not(AstFilter filter)
             return new AstNorFilter(new[] { filter });
         }
 
+        public static AstFieldOperationFilter NotExists(AstFilterField field)
+        {
+            return new AstFieldOperationFilter(field, new AstExistsFilterOperation(exists: false));
+        }
+
         public static AstFilter Or(params AstFilter[] filters)
         {
             Ensure.IsNotNull(filters, nameof(filters));
@@ -235,6 +240,11 @@ public static AstFieldOperationFilter Size(AstFilterField field, BsonValue size)
         {
             return new AstFieldOperationFilter(field, new AstSizeFilterOperation(size));
         }
+
+        public static AstFieldOperationFilter Type(AstFilterField field, BsonType type)
+        {
+            return new AstFieldOperationFilter(field, new AstTypeFilterOperation(type));
+        }
         #endregion
 
         // public properties
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/ObjectMethod.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/ObjectMethod.cs
@@ -21,17 +21,20 @@ internal static class ObjectMethod
     {
         // private static fields
         private static readonly MethodInfo __equals;
+        private static readonly MethodInfo __getType;
         private static readonly MethodInfo __toString;
 
         // static constructor
         static ObjectMethod()
         {
             __equals = ReflectionInfo.Method((object o, object obj) => o.Equals(obj));
+            __getType = ReflectionInfo.Method((object o) => o.GetType());
             __toString = ReflectionInfo.Method((object o) => o.ToString());
         }
 
         // public properties
         public static new MethodInfo Equals => __equals;
+        public static new MethodInfo GetType => __getType;
         public static new MethodInfo ToString => __toString;
     }
 }
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/BinaryExpressionToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/BinaryExpressionToAggregationExpressionTranslator.cs
@@ -30,6 +30,11 @@ internal static class BinaryExpressionToAggregationExpressionTranslator
     {
         public static AggregationExpression Translate(TranslationContext context, BinaryExpression expression)
         {
+            if (GetTypeComparisonExpressionToAggregationExpressionTranslator.CanTranslate(expression))
+            {
+                return GetTypeComparisonExpressionToAggregationExpressionTranslator.Translate(context, expression);
+            }
+
             if (StringGetCharsComparisonExpressionToAggregationExpressionTranslator.CanTranslate(expression, out var getCharsExpression))
             {
                 return StringGetCharsComparisonExpressionToAggregationExpressionTranslator.Translate(context, expression, getCharsExpression);
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/ExpressionToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/ExpressionToAggregationExpressionTranslator.cs
@@ -77,6 +77,8 @@ public static AggregationExpression Translate(TranslationContext context, Expres
                     return NewArrayInitExpressionToAggregationExpressionTranslator.Translate(context, (NewArrayExpression)expression);
                 case ExpressionType.Parameter:
                     return ParameterExpressionToAggregationExpressionTranslator.Translate(context, (ParameterExpression)expression);
+                case ExpressionType.TypeIs:
+                    return TypeIsExpressionToAggregationExpressionTranslator.Translate(context, (TypeBinaryExpression)expression);
             }
 
             throw new ExpressionNotSupportedException(expression);
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/GetTypeComparisonExpressionToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/GetTypeComparisonExpressionToAggregationExpressionTranslator.cs
@@ -0,0 +1,78 @@
+﻿/* Copyright 2010-present MongoDB Inc.
+*
+* 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.
+*/
+
+using System;
+using System.Linq.Expressions;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Driver.Linq.Linq3Implementation.Ast.Expressions;
+using MongoDB.Driver.Linq.Linq3Implementation.Misc;
+using MongoDB.Driver.Linq.Linq3Implementation.Reflection;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Translators.ExpressionToAggregationExpressionTranslators
+{
+    internal static class GetTypeComparisonExpressionToAggregationExpressionTranslator
+    {
+        // public static methods
+        public static bool CanTranslate(BinaryExpression expression)
+        {
+            return CanTranslate(expression, out _, out _);
+        }
+
+        public static AggregationExpression Translate(TranslationContext context, BinaryExpression expression)
+        {
+            if (CanTranslate(expression, out var getTypeMethodCallExpression, out var comparandType))
+            {
+                var objectExpression = getTypeMethodCallExpression.Object;
+                var objectTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, objectExpression);
+                var nominalType = objectExpression.Type;
+                var actualType = comparandType;
+
+                var discriminatorConvention = objectTranslation.Serializer is ObjectSerializer objectSerializer ?
+                    objectSerializer.DiscriminatorConvention :
+                    BsonSerializer.LookupDiscriminatorConvention(nominalType);
+                var discriminatorField = AstExpression.GetField(objectTranslation.Ast, discriminatorConvention.ElementName);
+                var discriminatorValue = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+
+                var ast = AstExpression.Eq(discriminatorField, discriminatorValue);
+                return new AggregationExpression(expression, ast, BooleanSerializer.Instance);
+            }
+
+            throw new ExpressionNotSupportedException(expression);
+        }
+
+        // private static methods
+        private static bool CanTranslate(BinaryExpression expression, out MethodCallExpression getTypeMethodCallExpression, out Type comparandType)
+        {
+            var leftExpression = expression.Left;
+            var rightExpression = expression.Right;
+
+            if (leftExpression is MethodCallExpression methodCallExpression &&
+                methodCallExpression.Method.Is(ObjectMethod.GetType) &&
+                expression.NodeType == ExpressionType.Equal &&
+                rightExpression is ConstantExpression constantExpression)
+            {
+                getTypeMethodCallExpression = methodCallExpression;
+                comparandType = (Type)constantExpression.Value;
+                return true;
+            }
+
+            getTypeMethodCallExpression = null;
+            comparandType = null;
+            return false;
+        }
+
+    }
+}
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/TypeIsExpressionToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/TypeIsExpressionToAggregationExpressionTranslator.cs
@@ -0,0 +1,54 @@
+﻿/* Copyright 2010-present MongoDB Inc.
+*
+* 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.
+*/
+
+using System.Linq;
+using System.Linq.Expressions;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Driver.Linq.Linq3Implementation.Ast.Expressions;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Translators.ExpressionToAggregationExpressionTranslators
+{
+    internal static class TypeIsExpressionToAggregationExpressionTranslator
+    {
+        // public static methods
+        public static AggregationExpression Translate(TranslationContext context, TypeBinaryExpression expression)
+        {
+            var objectExpression = expression.Expression;
+            var objectTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, objectExpression);
+            var nominalType = objectExpression.Type;
+            var actualType = expression.TypeOperand;
+
+            var discriminatorConvention = objectTranslation.Serializer is ObjectSerializer objectSerializer ?
+                objectSerializer.DiscriminatorConvention :
+                BsonSerializer.LookupDiscriminatorConvention(nominalType);
+            var discriminatorField = AstExpression.GetField(objectTranslation.Ast, discriminatorConvention.ElementName);
+            var discriminatorValue = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+            if (discriminatorValue is BsonArray array)
+            {
+                discriminatorValue = array.Last();
+            }
+
+            var ast = AstExpression.Or(
+                AstExpression.Eq(discriminatorField, discriminatorValue),
+                AstExpression.And(
+                    AstExpression.IsArray(discriminatorField),
+                    AstExpression.In(discriminatorValue, discriminatorField)));
+
+            return new AggregationExpression(expression, ast, BooleanSerializer.Instance);
+        }
+    }
+}
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/ComparisonExpressionToFilterTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/ComparisonExpressionToFilterTranslator.cs
@@ -56,6 +56,11 @@ public static AstFilter Translate(TranslationContext context, BinaryExpression e
                 return CountComparisonExpressionToFilterTranslator.Translate(context, expression, countExpression, sizeExpression);
             }
 
+            if (GetTypeComparisonExpressionToFilterTranslator.CanTranslate(leftExpression, rightExpression))
+            {
+                return GetTypeComparisonExpressionToFilterTranslator.Translate(context, expression, (MethodCallExpression)leftExpression, (ConstantExpression)rightExpression);
+            }
+
             if (ModuloComparisonExpressionToFilterTranslator.CanTranslate(leftExpression, rightExpression, out var moduloExpression, out var remainderExpression))
             {
                 return ModuloComparisonExpressionToFilterTranslator.Translate(context, expression, moduloExpression, remainderExpression);
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/GetTypeComparisonExpressionToFilterTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/GetTypeComparisonExpressionToFilterTranslator.cs
@@ -0,0 +1,74 @@
+﻿/* Copyright 2010-present MongoDB Inc.
+*
+* 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.
+*/
+
+using System;
+using System.Linq.Expressions;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Driver.Linq.Linq3Implementation.Ast.Filters;
+using MongoDB.Driver.Linq.Linq3Implementation.ExtensionMethods;
+using MongoDB.Driver.Linq.Linq3Implementation.Misc;
+using MongoDB.Driver.Linq.Linq3Implementation.Reflection;
+using MongoDB.Driver.Linq.Linq3Implementation.Translators.ExpressionToFilterTranslators.ToFilterFieldTranslators;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Translators.ExpressionToFilterTranslators.ExpressionTranslators
+{
+    internal static class GetTypeComparisonExpressionToFilterTranslator
+    {
+        // caller is responsible for ensuring constant is on the right
+        public static bool CanTranslate(Expression leftExpression, Expression rightExpression)
+        {
+            return
+                leftExpression is MethodCallExpression methodCallExpression &&
+                methodCallExpression.Method.Is(ObjectMethod.GetType) &&
+                rightExpression is ConstantExpression;
+        }
+
+        public static AstFilter Translate(TranslationContext context, BinaryExpression expression, MethodCallExpression getTypeExpression, Expression typeConstantExpression)
+        {
+            var field = ExpressionToFilterFieldTranslator.Translate(context, getTypeExpression.Object);
+            var nominalType = field.Serializer.ValueType;
+            var actualType = typeConstantExpression.GetConstantValue<Type>(expression);
+
+            var discriminatorConvention = field.Serializer is ObjectSerializer objectSerializer ?
+                objectSerializer.DiscriminatorConvention :
+                BsonSerializer.LookupDiscriminatorConvention(nominalType);
+            var discriminatorField = field.SubField(discriminatorConvention.ElementName, BsonValueSerializer.Instance);
+            var discriminatorValue = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+
+            if (discriminatorValue.IsBsonArray)
+            {
+                var discriminatorValues = discriminatorValue.AsBsonArray;
+                var filters = new AstFilter[discriminatorValues.Count + 1];
+                filters[0] = AstFilter.Size(discriminatorField, discriminatorValues.Count); // don't match subclasses
+                for (var i = 0; i < discriminatorValues.Count; i++)
+                {
+                    var discriminatorItemField = discriminatorField.SubField(i.ToString(), BsonValueSerializer.Instance);
+                    filters[i + 1] = AstFilter.Eq(discriminatorItemField, discriminatorValues[i]);
+                }
+
+                return AstFilter.And(filters);
+
+            }
+            else
+            {
+                var discriminatorFieldElementZero = discriminatorField.SubField("0", BsonValueSerializer.Instance);
+                return AstFilter.And(
+                    AstFilter.NotExists(discriminatorFieldElementZero), // required to avoid false matches on subclasses with hierarchical discriminators
+                    AstFilter.Eq(discriminatorField, discriminatorValue));
+            }
+        }
+    }
+}
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/TypeIsExpressionToFilterTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/TypeIsExpressionToFilterTranslator.cs
@@ -13,7 +13,9 @@
 * limitations under the License.
 */
 
+using System.Linq;
 using System.Linq.Expressions;
+using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver.Linq.Linq3Implementation.Ast.Filters;
@@ -29,14 +31,20 @@ public static AstFilter Translate(TranslationContext context, TypeBinaryExpressi
             {
                 var fieldExpression = expression.Expression;
                 var field = ExpressionToFilterFieldTranslator.Translate(context, fieldExpression);
-
                 var nominalType = fieldExpression.Type;
                 var actualType = expression.TypeOperand;
-                var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(actualType);
+
+                var discriminatorConvention = field.Serializer is ObjectSerializer objectSerializer ?
+                    objectSerializer.DiscriminatorConvention :
+                    BsonSerializer.LookupDiscriminatorConvention(actualType);
                 var discriminatorField = field.SubField(discriminatorConvention.ElementName, BsonValueSerializer.Instance);
-                var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+                var discriminatorValue = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+                if (discriminatorValue is BsonArray array)
+                {
+                    discriminatorValue = array.Last();
+                }
 
-                return AstFilter.Eq(discriminatorField, discriminator);
+                return AstFilter.Eq(discriminatorField, discriminatorValue); // will match subclasses also
             }
 
             throw new ExpressionNotSupportedException(expression);
diff --git a/tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Jira/CSharp4691Tests.cs b/tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Jira/CSharp4691Tests.cs

Original file line number	Diff line number	Diff line change
`@@ -453,6 +453,11 @@ public static AstExpression IndexOfCP(AstExpression @string, AstExpression value`
`453`	`453`	`return new AstIndexOfCPExpression(@string, value, start, end);`
`454`	`454`	`}`
`455`	`455`
	`456`	`+ public static AstExpression IsArray(AstExpression value)`
	`457`	`+ {`
	`458`	`+ return new AstUnaryExpression(AstUnaryOperator.IsArray, value);`
	`459`	`+ }`
	`460`	`+`
`456`	`461`	`public static AstExpression Last(AstExpression array)`
`457`	`462`	`{`
`458`	`463`	`return new AstUnaryExpression(AstUnaryOperator.Last, array);`
Original file line number	Diff line number	Diff line change
`@@ -195,6 +195,11 @@ public static AstFilter Not(AstFilter filter)`
`195`	`195`	`return new AstNorFilter(new[] { filter });`
`196`	`196`	`}`
`197`	`197`
	`198`	`+ public static AstFieldOperationFilter NotExists(AstFilterField field)`
	`199`	`+ {`
	`200`	`+ return new AstFieldOperationFilter(field, new AstExistsFilterOperation(exists: false));`
	`201`	`+ }`
	`202`	`+`
`198`	`203`	`public static AstFilter Or(params AstFilter[] filters)`
`199`	`204`	`{`
`200`	`205`	`Ensure.IsNotNull(filters, nameof(filters));`
`@@ -235,6 +240,11 @@ public static AstFieldOperationFilter Size(AstFilterField field, BsonValue size)`
`235`	`240`	`{`
`236`	`241`	`return new AstFieldOperationFilter(field, new AstSizeFilterOperation(size));`
`237`	`242`	`}`
	`243`	`+`
	`244`	`+ public static AstFieldOperationFilter Type(AstFilterField field, BsonType type)`
	`245`	`+ {`
	`246`	`+ return new AstFieldOperationFilter(field, new AstTypeFilterOperation(type));`
	`247`	`+ }`
`238`	`248`	`#endregion`
`239`	`249`
`240`	`250`	`// public properties`
Original file line number	Diff line number	Diff line change
`@@ -21,17 +21,20 @@ internal static class ObjectMethod`
`21`	`21`	`{`
`22`	`22`	`// private static fields`
`23`	`23`	`private static readonly MethodInfo __equals;`
	`24`	`+ private static readonly MethodInfo __getType;`
`24`	`25`	`private static readonly MethodInfo __toString;`
`25`	`26`
`26`	`27`	`// static constructor`
`27`	`28`	`static ObjectMethod()`
`28`	`29`	`{`
`29`	`30`	`__equals = ReflectionInfo.Method((object o, object obj) => o.Equals(obj));`
	`31`	`+ __getType = ReflectionInfo.Method((object o) => o.GetType());`
`30`	`32`	`__toString = ReflectionInfo.Method((object o) => o.ToString());`
`31`	`33`	`}`
`32`	`34`
`33`	`35`	`// public properties`
`34`	`36`	`public static new MethodInfo Equals => __equals;`
	`37`	`+ public static new MethodInfo GetType => __getType;`
`35`	`38`	`public static new MethodInfo ToString => __toString;`
`36`	`39`	`}`
`37`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,11 @@ internal static class BinaryExpressionToAggregationExpressionTranslator`
`30`	`30`	`{`
`31`	`31`	`public static AggregationExpression Translate(TranslationContext context, BinaryExpression expression)`
`32`	`32`	`{`
	`33`	`+ if (GetTypeComparisonExpressionToAggregationExpressionTranslator.CanTranslate(expression))`
	`34`	`+ {`
	`35`	`+ return GetTypeComparisonExpressionToAggregationExpressionTranslator.Translate(context, expression);`
	`36`	`+ }`
	`37`	`+`
`33`	`38`	`if (StringGetCharsComparisonExpressionToAggregationExpressionTranslator.CanTranslate(expression, out var getCharsExpression))`
`34`	`39`	`{`
`35`	`40`	`return StringGetCharsComparisonExpressionToAggregationExpressionTranslator.Translate(context, expression, getCharsExpression);`
Original file line number	Diff line number	Diff line change
`@@ -77,6 +77,8 @@ public static AggregationExpression Translate(TranslationContext context, Expres`
`77`	`77`	`return NewArrayInitExpressionToAggregationExpressionTranslator.Translate(context, (NewArrayExpression)expression);`
`78`	`78`	`case ExpressionType.Parameter:`
`79`	`79`	`return ParameterExpressionToAggregationExpressionTranslator.Translate(context, (ParameterExpression)expression);`
	`80`	`+ case ExpressionType.TypeIs:`
	`81`	`+ return TypeIsExpressionToAggregationExpressionTranslator.Translate(context, (TypeBinaryExpression)expression);`
`80`	`82`	`}`
`81`	`83`
`82`	`84`	`throw new ExpressionNotSupportedException(expression);`
Original file line number	Diff line number	Diff line change
`@@ -56,6 +56,11 @@ public static AstFilter Translate(TranslationContext context, BinaryExpression e`
`56`	`56`	`return CountComparisonExpressionToFilterTranslator.Translate(context, expression, countExpression, sizeExpression);`
`57`	`57`	`}`
`58`	`58`
	`59`	`+ if (GetTypeComparisonExpressionToFilterTranslator.CanTranslate(leftExpression, rightExpression))`
	`60`	`+ {`
	`61`	`+ return GetTypeComparisonExpressionToFilterTranslator.Translate(context, expression, (MethodCallExpression)leftExpression, (ConstantExpression)rightExpression);`
	`62`	`+ }`
	`63`	`+`
`59`	`64`	`if (ModuloComparisonExpressionToFilterTranslator.CanTranslate(leftExpression, rightExpression, out var moduloExpression, out var remainderExpression))`
`60`	`65`	`{`
`61`	`66`	`return ModuloComparisonExpressionToFilterTranslator.Translate(context, expression, moduloExpression, remainderExpression);`