Add STJ.Nodes.JsonArray.Remove(All|Range) (#109472)

* Close #107962. Add RemoveAll & RemoveRange to JsonArray.

* added exception messages; added tests;
fixed bug on trailing elements in RemoveAll

* Implement RemoveAll thru List<T>.RemoveAll with lambdas. Remove lazy-load checks in RemoveRange.

* Removed unused using statements

* added tests for freshly deserialized JsonArray

* fix formatting

* revert comments in auto-generated resource file

Author: karakasa

src/libraries/System.Text.Json/ref/System.Text.Json.cs

@@ -705,6 +705,8 @@ public void Clear() { }
         public void Insert(int index, System.Text.Json.Nodes.JsonNode? item) { }
         public bool Remove(System.Text.Json.Nodes.JsonNode? item) { throw null; }
         public void RemoveAt(int index) { }
+        public int RemoveAll(System.Func<System.Text.Json.Nodes.JsonNode?, bool> match) { throw null; }
+        public void RemoveRange(int index, int count) { }
         void System.Collections.Generic.ICollection<System.Text.Json.Nodes.JsonNode?>.CopyTo(System.Text.Json.Nodes.JsonNode?[]? array, int index) { }
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
         public override void WriteTo(System.Text.Json.Utf8JsonWriter writer, System.Text.Json.JsonSerializerOptions? options = null) { }

src/libraries/System.Text.Json/src/Resources/Strings.resx

@@ -807,4 +807,7 @@
   <data name="Arg_HTCapacityOverflow" xml:space="preserve">
     <value>Hashtable's capacity overflowed and went negative. Check load factor, capacity and the current size of the table.</value>
   </data>
+  <data name="Argument_InvalidOffLen" xml:space="preserve">
+    <value>Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection.</value>
+  </data>
 </root>

src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonArray.IList.cs

@@ -114,6 +114,78 @@ public void RemoveAt(int index)
             DetachParent(item);
         }
 
+        /// <summary>
+        ///   Removes all the elements that match the conditions defined by the specified predicate.
+        /// </summary>
+        /// <param name="match">The predicate that defines the conditions of the elements to remove.</param>
+        /// <returns>The number of elements removed from the <see cref="JsonArray"/>.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="match"/> is <see langword="null"/>.
+        /// </exception>
+        public int RemoveAll(Func<JsonNode?, bool> match)
+        {
+            if (match == null)
+            {
+                ThrowHelper.ThrowArgumentNullException(nameof(match));
+            }
+
+            return List.RemoveAll(node =>
+            {
+                if (match(node))
+                {
+                    DetachParent(node);
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            });
+        }
+
+        /// <summary>
+        ///   Removes a range of elements from the <see cref="JsonArray"/>.
+        /// </summary>
+        /// <param name="index">The zero-based starting index of the range of elements to remove.</param>
+        /// <param name="count">The number of elements to remove.</param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   <paramref name="index"/> or <paramref name="count"/> is less than 0.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="index"/> and <paramref name="count"/> do not denote a valid range of elements in the <see cref="JsonArray"/>.
+        /// </exception>
+        public void RemoveRange(int index, int count)
+        {
+            if (index < 0)
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(nameof(index));
+            }
+
+            if (count < 0)
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(nameof(count));
+            }
+
+            List<JsonNode?> list = List;
+
+            if (list.Count - index < count)
+            {
+                ThrowHelper.ThrowArgumentException_InvalidOffLen();
+            }
+
+            if (count > 0)
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    DetachParent(list[index + i]);
+                    // There's no need to assign nulls because List<>.RemoveRange calls
+                    // Array.Clear on the removed partition.
+                }
+
+                list.RemoveRange(index, count);
+            }
+        }
+
         #region Explicit interface implementation
 
         /// <summary>

src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.cs

@@ -65,6 +65,18 @@ public static void ThrowArgumentOutOfRangeException_JsonConverterFactory_TypeNot
             throw new ArgumentOutOfRangeException(nameof(typeToConvert), SR.Format(SR.SerializerConverterFactoryInvalidArgument, typeToConvert.FullName));
         }
 
+        [DoesNotReturn]
+        public static void ThrowArgumentOutOfRangeException_NeedNonNegNum(string paramName)
+        {
+            throw new ArgumentOutOfRangeException(paramName, SR.ArgumentOutOfRange_Generic_MustBeNonNegative);
+        }
+
+        [DoesNotReturn]
+        public static void ThrowArgumentException_InvalidOffLen()
+        {
+            throw new ArgumentException(SR.Argument_InvalidOffLen);
+        }
+
         [DoesNotReturn]
         public static void ThrowArgumentException_ArrayTooSmall(string paramName)
         {

src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonNode/JsonArrayTests.cs

@@ -768,5 +768,126 @@ public static void ReplaceWithJsonElement(string json)
 
             Assert.Equal($"[{json}]", array.ToJsonString());
         }
+
+        [Fact]
+        public static void RemoveAll_InvalidValuesAndEmptyArray()
+        {
+            JsonArray testArray = new();
+            Assert.Throws<ArgumentNullException>(() => testArray.RemoveAll(null!));
+            testArray.RemoveAll(whatever => true); // RemoveAll on empty array always succeeds.
+        }
+
+        [Fact]
+        public static void RemoveAll_FreshlyDeserialized()
+        {
+            JsonArray testArray = JsonSerializer.Deserialize<JsonArray>("[1,2,3,4,5]");
+            Assert.Equal(3, testArray.RemoveAll(val => val.GetValue<int>() % 2 == 1));
+            JsonNodeTests.AssertDeepEqual(new JsonArray { 2, 4 }, testArray);
+        }
+
+        [Theory]
+        [InlineData(new int[] { 1, 1, 1, 1, 1 }, new int[] { 1, 1, 1, 1, 1 }, 0)]
+        [InlineData(new int[] { 2, 1, 1, 1, 1 }, new int[] { 1, 1, 1, 1 }, 1)]
+        [InlineData(new int[] { 1, 1, 1, 1, 2 }, new int[] { 1, 1, 1, 1 }, 1)]
+        [InlineData(new int[] { 1, 1, 1, 2, 1 }, new int[] { 1, 1, 1, 1 }, 1)]
+        public static void RemoveAll_SpecialValues(int[] original, int[] expected, int removed)
+        {
+            // This test is to ensure the O(n) scan algorithm of JsonArray.RemoveAll is correct.
+
+            JsonArray testArray = new(ToNodes(original));
+            Assert.Equal(removed, testArray.RemoveAll(Filter));
+            JsonNodeTests.AssertDeepEqual(new JsonArray(ToNodes(expected)), testArray);
+
+            bool Filter(JsonNode? v) => v.GetValue<int>() > 1;
+            JsonNode?[] ToNodes(int[] values) => values.Select(v => JsonValue.Create(v)).ToArray();
+        }
+
+        [Fact]
+        public static void RemoveAll()
+        {
+            JsonArray testArray = [1, 2, 3, 4, 5, 7, 8, 8, 8];
+            JsonNode[] nodes = testArray.ToArray();
+
+            // Correct amount of nodes are removed / remaining
+            Assert.Equal(5, testArray.RemoveAll(Filter));
+            Assert.Equal(4, testArray.Count);
+
+            // The order is preserved
+            JsonNodeTests.AssertDeepEqual(new JsonArray { 1, 3, 5, 7 }, testArray);
+
+            // Node parents are correctly handled
+            foreach (JsonNode node in nodes)
+            {
+                if (Filter(node))
+                {
+                    Assert.Null(node.Parent);
+                }
+                else
+                {
+                    Assert.Same(testArray, node.Parent);
+                }
+            }
+
+            static bool Filter(JsonNode node) => node.GetValue<int>() % 2 == 0;
+        }
+
+        [Fact]
+        public static void RemoveRange_InvalidAndSpecialValues()
+        {
+            JsonArray emptyArray = new();
+            emptyArray.RemoveRange(0, 0);
+            Assert.Throws<ArgumentException>(() => emptyArray.RemoveRange(0, 1));
+            Assert.Throws<ArgumentException>(() => emptyArray.RemoveRange(1, 0));
+
+            JsonArray testArray = [1, 2, 3, 4, 5, 6, 7, 8];
+            Assert.Throws<ArgumentOutOfRangeException>(() => testArray.RemoveRange(-1, 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => testArray.RemoveRange(1, -1));
+            Assert.Throws<ArgumentException>(() => testArray.RemoveRange(10, 1));
+            Assert.Throws<ArgumentException>(() => testArray.RemoveRange(1, 10));
+        }
+
+        [Fact]
+        public static void RemoveRange()
+        {
+            JsonArray testArray = [1, 2, 3, 4, 5, 6, 7, 8];
+            JsonNode[] nodes = testArray.ToArray();
+
+            const int RemoveStartIndex = 3;
+            const int RemoveLength = 3;
+
+            testArray.RemoveRange(RemoveStartIndex, RemoveLength);
+            Assert.Equal(8 - RemoveLength, testArray.Count);
+            JsonNodeTests.AssertDeepEqual(new JsonArray { 1, 2, 3, 7, 8 }, testArray);
+
+            for (int i = 0; i < nodes.Length; i++)
+            {
+                if (IsIndexRemoved(i))
+                {
+                    Assert.Null(nodes[i].Parent);
+                }
+                else
+                {
+                    Assert.Same(testArray, nodes[i].Parent);
+                }
+            }
+
+            static bool IsIndexRemoved(int originalIndex) => originalIndex >= RemoveStartIndex &&
+                originalIndex < RemoveStartIndex + RemoveLength;
+        }
+
+        [Fact]
+        public static void RemoveRange_FreshlyDeserialized()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => PrepareData().RemoveRange(-1, 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => PrepareData().RemoveRange(1, -1));
+            Assert.Throws<ArgumentException>(() => PrepareData().RemoveRange(10, 1));
+            Assert.Throws<ArgumentException>(() => PrepareData().RemoveRange(1, 10));
+
+            JsonArray testArray = PrepareData();
+            testArray.RemoveRange(2, 2);
+            JsonNodeTests.AssertDeepEqual(new JsonArray { 1, 2, 5 }, testArray);
+
+            static JsonArray PrepareData() => JsonSerializer.Deserialize<JsonArray>("[1,2,3,4,5]");
+        }
     }
 }