Implementing stable sort

Jint.Tests/Runtime/ArrayTests.cs

@@ -74,5 +74,45 @@ public void ArrayLengthFromInitialState()
             var length = (int) array.Length;
             Assert.Equal(0, length);
         }
+
+        [Fact]
+        public void ArraySortIsStable()
+        {
+            const string code = @"
+                var items = [
+                    { name: 'Edward', value: 0 },
+                    { name: 'Sharpe', value: 0 },
+                    { name: 'And', value: 0 },
+                    { name: 'The', value: 1 },
+                    { name: 'Magnetic', value: 0 },
+                    { name: 'Zeros', value: 0 }
+                ];
+
+                // sort by value
+                function compare(a, b) {
+                    return a.value - b.value;
+                }
+
+                var a = items.sort();
+
+                assert(a[0].name == 'Edward');
+                assert(a[1].name == 'Sharpe');
+                assert(a[2].name == 'And');
+                assert(a[3].name == 'The');
+                assert(a[4].name == 'Magnetic');
+                assert(a[5].name == 'Zeros');
+
+                var a = items.sort(compare);
+
+                assert(a[0].name == 'Edward');
+                assert(a[1].name == 'Sharpe');
+                assert(a[2].name == 'And');
+                assert(a[3].name == 'Magnetic');
+                assert(a[4].name == 'Zeros');
+                assert(a[5].name == 'The');
+            ";
+
+            _engine.Execute(code);
+        }
     }
 }

Jint/Native/Array/ArrayOperations.cs

@@ -1,11 +1,13 @@
+using System.Collections;
+using System.Collections.Generic;
 using Jint.Native.Number;
 using Jint.Native.Object;
 using Jint.Runtime;
 using Jint.Runtime.Descriptors;
 
 namespace Jint.Native.Array
 {
-    internal abstract class ArrayOperations
+    internal abstract class ArrayOperations : IEnumerable<JsValue>
     {
         protected internal const ulong MaxArrayLength = 4294967295;
         protected internal const ulong MaxArrayLikeLength = NumberConstructor.MaxSafeInteger;
@@ -68,6 +70,60 @@ public virtual JsValue[] GetAll(Types elementTypes)
 
         public abstract void DeletePropertyOrThrow(ulong index);
 
+        public IEnumerator<JsValue> GetEnumerator()
+        {
+            return new ArrayOperationsIterator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        private sealed class ArrayOperationsIterator : IEnumerator<JsValue>
+        {
+            private readonly ArrayOperations _obj;
+            private ulong _current;
+            private bool _first;
+            private readonly uint _length;
+
+            public ArrayOperationsIterator(ArrayOperations obj)
+            {
+                _obj = obj;
+                _length = obj.GetLength();
+
+                Reset();
+            }
+
+            public JsValue Current => _obj.TryGetValue(_current, out var temp) ? temp : null;
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+
+            public bool MoveNext()
+            {
+                if (_first)
+                {
+                    _first = false;
+                }
+                else
+                {
+                    _current++;
+                }
+
+                return _current < _length;
+            }
+
+            public void Reset()
+            {
+                _first = true;
+                _current = 0;
+            }
+        }
+
         private sealed class ObjectInstanceOperations : ArrayOperations<ObjectInstance>
         {
             public ObjectInstanceOperations(ObjectInstance target) : base(target)

Jint/Native/Array/ArrayPrototype.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Jint.Collections;
 using Jint.Native.Object;
 using Jint.Native.Symbol;
@@ -803,71 +804,14 @@ private JsValue Sort(JsValue thisObj, JsValue[] arguments)
                 return obj.Target;
             }
 
-            int Comparer(JsValue x, JsValue y)
-            {
-                if (ReferenceEquals(x, null))
-                {
-                    return 1;
-                }
-
-                if (ReferenceEquals(y, null))
-                {
-                    return -1;
-                }
-
-                var xUndefined = x.IsUndefined();
-                var yUndefined = y.IsUndefined();
-                if (xUndefined && yUndefined)
-                {
-                    return 0;
-                }
-
-                if (xUndefined)
-                {
-                    return 1;
-                }
-
-                if (yUndefined)
-                {
-                    return -1;
-                }
-
-                if (compareFn != null)
-                {
-                    var s = TypeConverter.ToNumber(compareFn.Call(Undefined, new[] {x, y}));
-                    if (s < 0)
-                    {
-                        return -1;
-                    }
-
-                    if (s > 0)
-                    {
-                        return 1;
-                    }
-
-                    return 0;
-                }
-
-                var xString = TypeConverter.ToString(x);
-                var yString = TypeConverter.ToString(y);
-
-                var r = CompareOrdinal(xString, yString);
-                return r;
-            }
+
 
-            var array = new JsValue[len];
-            for (uint i = 0; i < (uint) array.Length; ++i)
-            {
-                var value = obj.TryGetValue(i, out var temp)
-                    ? temp
-                    : null;
-                array[i] = value;
-            }
+            JsValue[] array;
 
             // don't eat inner exceptions
             try
             {
-                System.Array.Sort(array, Comparer);
+                array = obj.OrderBy(x => x, new ArrayComparer(compareFn)).ToArray();
             }
             catch (InvalidOperationException e)
             {
@@ -1290,5 +1234,67 @@ public JsValue Pop(JsValue thisObject, JsValue[] arguments)
             o.SetLength(len);
             return element;
         }
+
+        private sealed class ArrayComparer : IComparer<JsValue>
+        {
+            private readonly ICallable _compare;
+            public ArrayComparer(ICallable compare)
+            {
+                _compare = compare;
+            }
+
+            public int Compare(JsValue x, JsValue y)
+            {
+                if (ReferenceEquals(x, null))
+                {
+                    return 1;
+                }
+
+                if (ReferenceEquals(y, null))
+                {
+                    return -1;
+                }
+
+                var xUndefined = x.IsUndefined();
+                var yUndefined = y.IsUndefined();
+                if (xUndefined && yUndefined)
+                {
+                    return 0;
+                }
+
+                if (xUndefined)
+                {
+                    return 1;
+                }
+
+                if (yUndefined)
+                {
+                    return -1;
+                }
+
+                if (_compare != null)
+                {
+                    var s = TypeConverter.ToNumber(_compare.Call(Undefined, new[] {x, y}));
+                    if (s < 0)
+                    {
+                        return -1;
+                    }
+
+                    if (s > 0)
+                    {
+                        return 1;
+                    }
+
+                    return 0;
+                }
+
+                var xString = TypeConverter.ToString(x);
+                var yString = TypeConverter.ToString(y);
+
+                var r = CompareOrdinal(xString, yString);
+                return r;
+            }
+        }
     }
+
 }