CSHARP-4486: Add support for bitwise operators.

Author: rstam

src/MongoDB.Driver.Core/Core/Misc/Feature.cs

@@ -45,6 +45,7 @@ public class Feature
         private static readonly Feature __aggregateToString = new Feature("AggregateToString", WireVersion.Server40);
         private static readonly Feature __aggregateUnionWith = new Feature("AggregateUnionWith", WireVersion.Server44);
         private static readonly Feature __arrayFilters = new Feature("ArrayFilters", WireVersion.Server36);
+        private static readonly Feature __bitwiseOperators = new Feature("BitwiseOperators", WireVersion.Server63);
         private static readonly Feature __bypassDocumentValidation = new Feature("BypassDocumentValidation", WireVersion.Server32);
         private static readonly Feature __changeStreamStage = new Feature("ChangeStreamStage", WireVersion.Server36);
         private static readonly Feature __changeStreamAllChangesForCluster = new Feature("ChangeStreamAllChangesForCluster", WireVersion.Server40);
@@ -261,6 +262,11 @@ public class Feature
         [Obsolete("This property will be removed in a later release.")]
         public static Feature ArrayFilters => __arrayFilters;
 
+        /// <summary>
+        /// Gets the bitwise operators feature.
+        /// </summary>
+        public static Feature BitwiseOperators => __bitwiseOperators;
+
         /// <summary>
         /// Gets the bypass document validation feature.
         /// </summary>

src/MongoDB.Driver/Linq/Linq3Implementation/Ast/AstNodeType.cs

@@ -20,7 +20,6 @@ internal enum AstNodeType
         AccumulatorField,
         AddFieldsStage,
         AllFilterOperation,
-        AndExpression,
         AndFilter,
         BinaryExpression,
         BinaryWindowExpression,
@@ -103,7 +102,6 @@ internal enum AstNodeType
         NorFilter,
         NotFilterOperation,
         NullaryWindowExpression,
-        OrExpression,
         OrFilter,
         OutStage,
         PickAccumulatorExpression,

src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Expressions/AstAndExpression.cs

@@ -80,24 +80,8 @@ public static AstExpression Add(params AstExpression[] args)
                 return new AstConstantExpression(value);
             }
 
-            if (args.Any(arg => arg is AstNaryExpression naryExpression && naryExpression.Operator == AstNaryOperator.Add))
-            {
-                var flattenedArgs = new List<AstExpression>();
-                foreach (var arg in args)
-                {
-                    if (arg is AstNaryExpression naryExpression && naryExpression.Operator == AstNaryOperator.Add)
-                    {
-                        flattenedArgs.AddRange(naryExpression.Args);
-                    }
-                    else
-                    {
-                        flattenedArgs.Add(arg);
-                    }
-                }
-                return new AstNaryExpression(AstNaryOperator.Add, flattenedArgs);
-            }
-
-            return new AstNaryExpression(AstNaryOperator.Add, args);
+            var flattenedArgs = FlattenNaryArgs(args, AstNaryOperator.Add);
+            return new AstNaryExpression(AstNaryOperator.Add, flattenedArgs);
         }
 
         public static AstExpression AllElementsTrue(AstExpression array)
@@ -122,24 +106,8 @@ public static AstExpression And(params AstExpression[] args)
                 return new AstConstantExpression(value);
             }
 
-            if (args.Any(arg => arg.NodeType == AstNodeType.AndExpression))
-            {
-                var flattenedArgs = new List<AstExpression>();
-                foreach (var arg in args)
-                {
-                    if (arg is AstAndExpression andExpression)
-                    {
-                        flattenedArgs.AddRange(andExpression.Args);
-                    }
-                    else
-                    {
-                        flattenedArgs.Add(arg);
-                    }
-                }
-                return new AstAndExpression(flattenedArgs);
-            }
-
-            return new AstAndExpression(args);
+            var flattenedArgs = FlattenNaryArgs(args, AstNaryOperator.And);
+            return new AstNaryExpression(AstNaryOperator.And, flattenedArgs);
         }
 
         public static AstExpression ArrayElemAt(AstExpression array, AstExpression index)
@@ -162,6 +130,42 @@ public static AstExpression BinaryWindowExpression(AstBinaryWindowOperator @oper
             return new AstBinaryWindowExpression(@operator, arg1, arg2, window);
         }
 
+        public static AstExpression BitAnd(params AstExpression[] args)
+        {
+            Ensure.IsNotNull(args, nameof(args));
+            Ensure.That(args.Length > 0, "args cannot be empty.", nameof(args));
+            Ensure.That(!args.Contains(null), "args cannot contain null.", nameof(args));
+
+            var flattenedArgs = FlattenNaryArgs(args, AstNaryOperator.BitAnd);
+            return new AstNaryExpression(AstNaryOperator.BitAnd, flattenedArgs);
+        }
+
+        public static AstExpression BitNot(AstExpression arg)
+        {
+            Ensure.IsNotNull(arg, nameof(arg));
+            return new AstUnaryExpression(AstUnaryOperator.BitNot, arg);
+        }
+
+        public static AstExpression BitOr(params AstExpression[] args)
+        {
+            Ensure.IsNotNull(args, nameof(args));
+            Ensure.That(args.Length > 0, "args cannot be empty.", nameof(args));
+            Ensure.That(!args.Contains(null), "args cannot contain null.", nameof(args));
+
+            var flattenedArgs = FlattenNaryArgs(args, AstNaryOperator.BitOr);
+            return new AstNaryExpression(AstNaryOperator.BitOr, flattenedArgs);
+        }
+
+        public static AstExpression BitXor(params AstExpression[] args)
+        {
+            Ensure.IsNotNull(args, nameof(args));
+            Ensure.That(args.Length > 0, "args cannot be empty.", nameof(args));
+            Ensure.That(!args.Contains(null), "args cannot contain null.", nameof(args));
+
+            var flattenedArgs = FlattenNaryArgs(args, AstNaryOperator.BitXor);
+            return new AstNaryExpression(AstNaryOperator.BitXor, flattenedArgs);
+        }
+
         public static AstExpression Ceil(AstExpression arg)
         {
             return new AstUnaryExpression(AstUnaryOperator.Ceil, arg);
@@ -213,24 +217,8 @@ public static IEnumerable<AstComputedField> ComputedFields(params (string name,
 
         public static AstExpression Concat(params AstExpression[] args)
         {
-            if (args.Any(a => a is AstNaryExpression naryExpression && naryExpression.Operator == AstNaryOperator.Concat))
-            {
-                var flattenedArgs = new List<AstExpression>();
-                foreach (var arg in args)
-                {
-                    if (arg is AstNaryExpression naryExpression && naryExpression.Operator == AstNaryOperator.Concat)
-                    {
-                        flattenedArgs.AddRange(naryExpression.Args);
-                    }
-                    else
-                    {
-                        flattenedArgs.Add(arg);
-                    }
-                }
-                return new AstNaryExpression(AstNaryOperator.Concat, flattenedArgs);
-            }
-
-            return new AstNaryExpression(AstNaryOperator.Concat, args);
+            var flattenedArgs = FlattenNaryArgs(args, AstNaryOperator.Concat);
+            return new AstNaryExpression(AstNaryOperator.Concat, flattenedArgs);
         }
 
         public static AstExpression ConcatArrays(params AstExpression[] arrays)
@@ -568,25 +556,8 @@ public static AstExpression Mod(AstExpression arg1, AstExpression arg2)
 
         public static AstExpression Multiply(params AstExpression[] args)
         {
-            if (args.Any(arg => arg is AstNaryExpression naryExpression && naryExpression.Operator == AstNaryOperator.Multiply))
-            {
-                var flattenedArgs = new List<AstExpression>();
-                foreach (var arg in args)
-                {
-                    if (arg is AstNaryExpression naryExpression && naryExpression.Operator == AstNaryOperator.Multiply)
-                    {
-                        flattenedArgs.AddRange(naryExpression.Args);
-                    }
-                    else
-                    {
-                        flattenedArgs.Add(arg);
-                    }
-                }
-                return new AstNaryExpression(AstNaryOperator.Multiply, flattenedArgs);
-            }
-
-
-            return new AstNaryExpression(AstNaryOperator.Multiply, args);
+            var flattenedArgs = FlattenNaryArgs(args, AstNaryOperator.Multiply);
+            return new AstNaryExpression(AstNaryOperator.Multiply, flattenedArgs);
         }
 
         public static AstExpression Ne(AstExpression arg1, AstExpression arg2)
@@ -610,24 +581,8 @@ public static AstExpression Or(params AstExpression[] args)
             Ensure.That(args.Length > 0, "args cannot be empty.", nameof(args));
             Ensure.That(!args.Contains(null), "args cannot contain null.", nameof(args));
 
-            if (args.Any(a => a.NodeType == AstNodeType.OrExpression))
-            {
-                var flattenedArgs = new List<AstExpression>();
-                foreach (var arg in args)
-                {
-                    if (arg is AstOrExpression orExpression)
-                    {
-                        flattenedArgs.AddRange(orExpression.Args);
-                    }
-                    else
-                    {
-                        flattenedArgs.Add(arg);
-                    }
-                }
-                return new AstOrExpression(flattenedArgs);
-            }
-
-            return new AstOrExpression(args);
+            var flattenedArgs = FlattenNaryArgs(args, AstNaryOperator.Or);
+            return new AstNaryExpression(AstNaryOperator.Or, flattenedArgs);
         }
 
         public static AstExpression PickExpression(AstPickOperator @operator, AstExpression source, AstSortFields sortBy, AstVarExpression @as, AstExpression selector, AstExpression n)
@@ -951,6 +906,28 @@ private static bool AllArgsAreConstantInt32s(AstExpression[] args, out List<int>
             values = null;
             return false;
         }
+
+        private static IEnumerable<AstExpression> FlattenNaryArgs(IEnumerable<AstExpression> args, AstNaryOperator naryOperator)
+        {
+            if (args.Any(arg => arg is AstNaryExpression naryExpression && naryExpression.Operator == naryOperator))
+            {
+                var flattenedArgs = new List<AstExpression>();
+                foreach (var arg in args)
+                {
+                    if (arg is AstNaryExpression naryExpression && naryExpression.Operator == naryOperator)
+                    {
+                        flattenedArgs.AddRange(naryExpression.Args);
+                    }
+                    else
+                    {
+                        flattenedArgs.Add(arg);
+                    }
+                }
+                return flattenedArgs;
+            }
+
+            return args;
+        }
         #endregion static
 
         // public methods

src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Expressions/AstExpression.cs

@@ -31,6 +31,7 @@ public AstNaryExpression(AstNaryOperator @operator, IEnumerable<AstExpression> a
         {
             _operator = @operator;
             _args = Ensure.IsNotNull(args, nameof(args)).AsReadOnlyList();
+            Ensure.That(!args.Contains(null), "args cannot contain null.", nameof(args));
         }
 
         public AstNaryExpression(AstNaryOperator @operator, params AstExpression[] args)

src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Expressions/AstNaryExpression.cs

@@ -20,13 +20,18 @@ namespace MongoDB.Driver.Linq.Linq3Implementation.Ast.Expressions
     internal enum AstNaryOperator
     {
         Add,
+        And,
         Avg,
+        BitAnd,
+        BitOr,
+        BitXor,
         Concat,
         ConcatArrays,
         Max,
         MergeObjects,
         Min,
         Multiply,
+        Or,
         SetEquals,
         SetIntersection,
         SetUnion,
@@ -42,13 +47,18 @@ public static string Render(this AstNaryOperator @operator)
             return @operator switch
             {
                 AstNaryOperator.Add => "$add",
+                AstNaryOperator.And => "$and",
                 AstNaryOperator.Avg => "$avg",
+                AstNaryOperator.BitAnd => "$bitAnd",
+                AstNaryOperator.BitOr => "$bitOr",
+                AstNaryOperator.BitXor => "$bitXor",
                 AstNaryOperator.Concat => "$concat",
                 AstNaryOperator.ConcatArrays => "$concatArrays",
                 AstNaryOperator.Max => "$max",
                 AstNaryOperator.MergeObjects => "$mergeObjects",
                 AstNaryOperator.Min => "$min",
                 AstNaryOperator.Multiply => "$multiply",
+                AstNaryOperator.Or => "$or",
                 AstNaryOperator.SetEquals => "$setEquals",
                 AstNaryOperator.SetIntersection => "$setIntersection",
                 AstNaryOperator.SetUnion => "$setUnion",