CSHARP-5572: Refactor to use a single IsSetEqualsMethod implementation

Author: rstam

src/MongoDB.Driver/Linq/Linq3Implementation/Misc/TypeExtensions.cs

@@ -190,6 +190,18 @@ public static bool ImplementsIQueryableOf(this Type type, Type itemType)
                 actualItemType == itemType;
         }
 
+        public static bool ImplementsISet(this Type type, out Type itemType)
+        {
+            if (TryGetISetGenericInterface(type, out var isetType))
+            {
+                itemType = isetType.GetGenericArguments()[0];
+                return true;
+            }
+
+            itemType = null;
+            return false;
+        }
+
         public static bool Is(this Type type, Type comparand)
         {
             if (type == comparand)
@@ -436,6 +448,9 @@ public static bool TryGetIOrderedQueryableGenericInterface(this Type type, out T
         public static bool TryGetIQueryableGenericInterface(this Type type, out Type iqueryableGenericInterface)
             => TryGetGenericInterface(type, typeof(IQueryable<>), out iqueryableGenericInterface);
 
+        public static bool TryGetISetGenericInterface(this Type type, out Type isetGenericInterface)
+            => TryGetGenericInterface(type, typeof(ISet<>), out isetGenericInterface);
+
         private static TValue GetDefaultValueGeneric<TValue>()
         {
             return default(TValue);

src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/ISetMethod.cs

@@ -0,0 +1,41 @@
+/* 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.Collections.Generic;
+using System.Reflection;
+using MongoDB.Driver.Linq.Linq3Implementation.Misc;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Reflection
+{
+    internal static class ISetMethod
+    {
+        // public static methods
+        public static bool IsSetEqualsMethod(MethodInfo method)
+        {
+            // many types implement a SetEquals method but the declaringType should always implement ISet<T>
+            var declaringType = method.DeclaringType;
+            return
+                declaringType.ImplementsISet(out var itemType) &&
+                method.IsPublic &&
+                !method.IsStatic &&
+                method.ReturnType == typeof(bool) &&
+                method.Name == "SetEquals" &&
+                method.GetParameters() is var parameters &&
+                parameters.Length == 1 &&
+                parameters[0] is var otherParameter &&
+                otherParameter.ParameterType == typeof(IEnumerable<>).MakeGenericType(itemType);
+        }
+    }
+}

src/MongoDB.Driver/Linq/Linq3Implementation/SerializerFinders/SerializerFinderVisitMethodCall.cs

@@ -2939,7 +2939,7 @@ void DeduceSequenceEqualMethodSerializers()
 
         void DeduceSetEqualsMethodSerializers()
         {
-            if (IsSetEqualsMethod(method))
+            if (ISetMethod.IsSetEqualsMethod(method))
             {
                 var objectExpression =  node.Object;
                 var otherExpression = arguments[0];
@@ -2951,22 +2951,6 @@ void DeduceSetEqualsMethodSerializers()
             {
                 DeduceUnknownMethodSerializer();
             }
-
-            static bool IsSetEqualsMethod(MethodInfo method)
-            {
-                var declaringType = method.DeclaringType;
-                var parameters = method.GetParameters();
-                return
-                    method.IsPublic &&
-                    method.IsStatic == false &&
-                    method.ReturnType == typeof(bool) &&
-                    method.Name == "SetEquals" &&
-                    parameters.Length == 1 &&
-                    parameters[0] is var otherParameter &&
-                    declaringType.ImplementsIEnumerable(out var declaringTypeItemType) &&
-                    otherParameter.ParameterType.ImplementsIEnumerable(out var otherTypeItemType) &&
-                    otherTypeItemType == declaringTypeItemType;
-            }
         }
 
         void DeduceSetWindowFieldsMethodSerializers()

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/SetEqualsMethodToAggregationExpressionTranslator.cs

@@ -17,15 +17,19 @@
 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.MethodTranslators
 {
     internal static class SetEqualsMethodToAggregationExpressionTranslator
     {
         public static TranslatedExpression Translate(TranslationContext context, MethodCallExpression expression)
         {
-            if (IsSetEqualsMethod(expression, out var objectExpression, out var otherExpression))
+            if (ISetMethod.IsSetEqualsMethod(expression.Method))
             {
+                var objectExpression = expression.Object;
+                var otherExpression = expression.Arguments[0];
+
                 var objectTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, objectExpression);
                 var otherTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, otherExpression);
                 var ast = AstExpression.SetEquals(objectTranslation.Ast, otherTranslation.Ast);
@@ -34,34 +38,5 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
             }
             throw new ExpressionNotSupportedException(expression);
         }
-
-        private static bool IsSetEqualsMethod(MethodCallExpression expression, out Expression objectExpression, out Expression otherExpression)
-        {
-            var method = expression.Method;
-            var arguments = expression.Arguments;
-
-            if (!method.IsStatic &&
-                method.ReturnType == typeof(bool) &&
-                method.Name == "SetEquals" &&
-                arguments.Count == 1)
-            {
-                objectExpression = expression.Object;
-                otherExpression = arguments[0];
-                if (objectExpression.Type.TryGetIEnumerableGenericInterface(out var objectEnumerableInterface) &&
-                    otherExpression.Type.TryGetIEnumerableGenericInterface(out var otherEnumerableInterface))
-                {
-                    var objectItemType = objectEnumerableInterface.GetGenericArguments()[0];
-                    var otherItemType = otherEnumerableInterface.GetGenericArguments()[0];
-                    if (objectItemType == otherItemType)
-                    {
-                        return true;
-                    }
-                }
-            }
-
-            objectExpression = null;
-            otherExpression = null;
-            return false;
-        }
     }
 }