CSHARP-1650: Refactor implementation of Split translation.

Author: rstam

src/MongoDB.Bson/ObjectModel/BsonTypeMapper.cs

@@ -35,6 +35,7 @@ public static class BsonTypeMapper
             { typeof(bool), Conversion.NewBsonBoolean },
             { typeof(byte), Conversion.ByteToBsonInt32 },
             { typeof(byte[]), Conversion.ByteArrayToBsonBinary },
+            { typeof(char), Conversion.CharToBsonInt32 },
             { typeof(DateTime), Conversion.DateTimeToBsonDateTime },
             { typeof(double), Conversion.NewBsonDouble },
             { typeof(float), Conversion.SingleToBsonDouble },
@@ -85,6 +86,7 @@ public static class BsonTypeMapper
             { Mapping.FromTo(typeof(byte), BsonType.Int64), Conversion.ByteToBsonInt64 },
             { Mapping.FromTo(typeof(byte[]), BsonType.Binary), Conversion.ByteArrayToBsonBinary },
             { Mapping.FromTo(typeof(byte[]), BsonType.ObjectId), Conversion.ByteArrayToBsonObjectId },
+            { Mapping.FromTo(typeof(char), BsonType.Int32), Conversion.CharToBsonInt32 },
             { Mapping.FromTo(typeof(DateTime), BsonType.DateTime), Conversion.DateTimeToBsonDateTime },
             { Mapping.FromTo(typeof(DateTimeOffset), BsonType.DateTime), Conversion.DateTimeOffsetToBsonDateTime },
             { Mapping.FromTo(typeof(double), BsonType.Boolean), Conversion.DoubleToBsonBoolean },

src/MongoDB.Driver/Linq/Translators/AggregateLanguageTranslator.cs

@@ -977,56 +977,47 @@ private bool TryTranslateStringMethodCall(MethodCallExpression node, out BsonVal
                     }
                     break;
                 case "Split":
-                    BsonValue separator = null;
-                    var separatorConstant = node.Arguments[0] as ConstantExpression;
-                    if (separatorConstant != null && separatorConstant.Type == typeof(char[]))
+                    if (node.Arguments.Count < 1)
                     {
-                        var chars = (char[])separatorConstant.Value;
-                        if (chars.Length == 1)
-                        {
-                            separator = new BsonString(new string(chars));
-                        }
+                        return false;
                     }
-                    else
+                    if (node.Arguments[0].Type != typeof(char[]) && node.Arguments[0].Type != typeof(string[]))
                     {
-                        separator = TranslateValue(node.Arguments[0]);
-                        var array = separator as BsonArray;
-                        if (array != null && array.Count == 1)
-                        {
-                            separator = array[0];
-                        }
-                        else if (array != null)
-                        {
-                            separator = null;
-                        }
+                        return false;
                     }
-
-                    if (separator != null)
+                    var separatorArray = TranslateValue(node.Arguments[0]) as BsonArray;
+                    if (separatorArray == null || separatorArray.Count != 1)
+                    {
+                        return false;
+                    }
+                    var separator = separatorArray[0];
+                    if (separator.BsonType == BsonType.Int32)
                     {
-                        if (node.Arguments.Count == 1)
+                        separator = new BsonString(new string((char)separator.AsInt32, 1));
+                    }
+                    if (node.Arguments.Count == 2)
+                    {
+                        var constantExpression = node.Arguments[1] as ConstantExpression;
+                        if (constantExpression == null || constantExpression.Type != typeof(StringSplitOptions))
                         {
-                            result = new BsonDocument("$split", new BsonArray
-                            {
-                                field,
-                                separator
-                            });
-                            return true;
+                            return false;
                         }
-                        else if (node.Arguments.Count == 2 && node.Arguments[1].Type == typeof(StringSplitOptions))
+                        var options = (StringSplitOptions)constantExpression.Value;
+                        if (options != StringSplitOptions.None)
                         {
-                            var splitOptions = node.Arguments[1] as ConstantExpression;
-                            if (splitOptions != null && ((StringSplitOptions)splitOptions.Value) == StringSplitOptions.None)
-                            {
-                                result = new BsonDocument("$split", new BsonArray
-                                {
-                                    field,
-                                    separator
-                                });
-                                return true;
-                            }
+                            return false;
                         }
                     }
-                    break;
+                    if (node.Arguments.Count > 2)
+                    {
+                        return false;
+                    }
+                    result = new BsonDocument("$split", new BsonArray
+                    {
+                        field,
+                        separator
+                    });
+                    return true;
                 case "Substring":
                     if (node.Arguments.Count == 2)
                     {