Skip to content

Add whitespace handling methods to MemoryExtensions #111439

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
AlexRadch wants to merge 11 commits into
base: main
Choose a base branch
from
Open

Add whitespace handling methods to MemoryExtensions #111439

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
b35693b
Add whitespace handling methods to MemoryExtensions
AlexRadch Jan 14, 2025
ad80463
Remove unused TestUtilities import in tests
AlexRadch Jan 14, 2025
e4069c1
Tests bugs have been fixed.
AlexRadch Jan 14, 2025
b495165
Apply suggestions from code review
AlexRadch Jan 15, 2025
3f77a0f
Suggestions from code review
AlexRadch Jan 15, 2025
866b91d
Remove unused namespaces in SearchValues.cs
AlexRadch Jan 15, 2025
bb9f9f4
Replaced references to `SearchValues.WhiteSpaces` with
AlexRadch Jan 17, 2025
5b45997
Remove unused using directive in MemoryExtensions
AlexRadch Jan 17, 2025
955d795
Merge branch 'main' into MemoryExtensions.WhiteSpace
jeffhandley Sep 1, 2025
8b8e577
Apply suggestion from @PranavSenthilnathan
AlexRadch Feb 19, 2026
3e4f067
Merge branch 'main' into MemoryExtensions.WhiteSpace
jeffhandley Mar 23, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 5 additions & 0 deletions src/libraries/System.Memory/ref/System.Memory.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -285,6 +285,7 @@ public static partial class MemoryExtensions
public static bool ContainsAnyInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
public static bool ContainsAnyInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
public static bool ContainsAnyWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static void CopyTo<T>(this T[]? source, System.Memory<T> destination) { }
public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
Expand Down Expand Up @@ -353,6 +354,7 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
public static int IndexOfAnyExceptInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
public static int IndexOfAnyExceptInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
public static int IndexOfAnyExceptWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static int IndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
public static int IndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
public static int IndexOf<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
Expand All @@ -364,6 +366,7 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
public static int IndexOfAnyInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
public static int IndexOfAnyInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
public static int IndexOfAnyWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static bool IsWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static int LastIndexOf(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
Expand Down Expand Up @@ -403,6 +406,7 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
public static int LastIndexOfAnyExceptInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
public static int LastIndexOfAnyExceptInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
public static int LastIndexOfAnyExceptWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static int LastIndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
public static int LastIndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
public static int LastIndexOf<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
Expand All @@ -414,6 +418,7 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
public static int LastIndexOfAnyInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
public static int LastIndexOfAnyInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
public static int LastIndexOfAnyWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static bool Overlaps<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other) { throw null; }
public static bool Overlaps<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other, out int elementOffset) { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
Expand Down
261 changes: 261 additions & 0 deletions src/libraries/System.Memory/tests/ReadOnlySpan/WhiteSpace.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,261 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

Copy link
Copy Markdown
Member

@PranavSenthilnathan PranavSenthilnathan Dec 3, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change


using System.Collections.Generic;
using System.Runtime.InteropServices;
using Xunit;

namespace System.SpanTests
{
public static partial class ReadOnlySpanTests
{
[Fact]
public static void IsWhiteSpace_True()
{
Assert.True(Span<char>.Empty.IsWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.True(CollectionsMarshal.AsSpan(chars).IsWhiteSpace());
}

[Fact]
public static void IsWhiteSpace_False()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
Assert.False(span.IsWhiteSpace());
}
}
}

[Fact]
public static void ContainsAnyWhiteSpace_Found()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
Assert.True(span.ContainsAnyWhiteSpace());
}
}
}

[Fact]
public static void ContainsAnyWhiteSpace_NotFound()
{
Assert.False(Span<char>.Empty.ContainsAnyWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.False(CollectionsMarshal.AsSpan(chars).ContainsAnyWhiteSpace());
}

[Fact]
public static void IndexOfAnyWhiteSpace_Found()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
chars[index + 1] = (char)i;
Assert.Equal(index, span.IndexOfAnyWhiteSpace());
}
}
}

[Fact]
public static void IndexOfAnyWhiteSpace_NotFound()
{
Assert.Equal(-1, Span<char>.Empty.IndexOfAnyWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.Equal(-1, CollectionsMarshal.AsSpan(chars).IndexOfAnyWhiteSpace());
}

[Fact]
public static void IndexOfAnyExceptWhiteSpace_Found()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
chars[index + 1] = (char)i;
Assert.Equal(index, span.IndexOfAnyExceptWhiteSpace());
}
}
}

[Fact]
public static void IndexOfAnyExceptWhiteSpace_NotFound()
{
Assert.Equal(-1, Span<char>.Empty.IndexOfAnyExceptWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.Equal(-1, CollectionsMarshal.AsSpan(chars).IndexOfAnyExceptWhiteSpace());
}

[Fact]
public static void LastIndexOfAnyWhiteSpace_Found()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
chars[index + 1] = (char)i;
Assert.Equal(index + 1, span.LastIndexOfAnyWhiteSpace());
}
}
}

[Fact]
public static void LastIndexOfAnyWhiteSpace_NotFound()
{
Assert.Equal(-1, Span<char>.Empty.LastIndexOfAnyWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.Equal(-1, CollectionsMarshal.AsSpan(chars).LastIndexOfAnyWhiteSpace());
}

[Fact]
public static void LastIndexOfAnyExceptWhiteSpace_Found()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
chars[index + 1] = (char)i;
Assert.Equal(index + 1, span.LastIndexOfAnyExceptWhiteSpace());
}
}
}

[Fact]
public static void LastIndexOfAnyExceptWhiteSpace_NotFound()
{
Assert.Equal(-1, Span<char>.Empty.LastIndexOfAnyExceptWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.Equal(-1, CollectionsMarshal.AsSpan(chars).LastIndexOfAnyExceptWhiteSpace());
}
}
}
1 change: 1 addition & 0 deletions src/libraries/System.Memory/tests/System.Memory.Tests.csproj
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -196,6 +196,7 @@
<Compile Include="ReadOnlySpan\ToArray.cs" />
<Compile Include="ReadOnlySpan\ToString.cs" />
<Compile Include="ReadOnlySpan\ToUpperLower.cs" />
<Compile Include="ReadOnlySpan\WhiteSpace.cs" />
</ItemGroup>
<ItemGroup>
<Compile Include="Memory\AsMemory.cs" />
Expand Down
58 changes: 49 additions & 9 deletions src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.Globalization.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,15 +14,9 @@ public static partial class MemoryExtensions
/// <summary>
/// Indicates whether the specified span contains only white-space characters.
/// </summary>
public static bool IsWhiteSpace(this ReadOnlySpan<char> span)
{
for (int i = 0; i < span.Length; i++)
{
if (!char.IsWhiteSpace(span[i]))
return false;
}
return true;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
Copy link
Copy Markdown
Member

@huoyaoyuan huoyaoyuan Feb 19, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

In don't think these trivial methods require AggressiveInlining.

Copy link
Copy Markdown
Member

@jeffhandley jeffhandley Mar 23, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@AlexRadch Did you do analysis to see if the AggressiveInlining hint made a difference in the JIT output and/or performance by chance? I believe @huoyaoyuan is asserting that the JIT would likely inline them even without the attribute.

public static bool IsWhiteSpace(this ReadOnlySpan<char> span) =>
!string.SearchValuesStorage.WhiteSpaceChars.ContainsAnyExcept(span);

/// <summary>
/// Returns a value indicating whether the specified <paramref name="value"/> occurs within the <paramref name="span"/>.
Expand All @@ -35,6 +29,16 @@ public static bool Contains(this ReadOnlySpan<char> span, ReadOnlySpan<char> val
return IndexOf(span, value, comparisonType) >= 0;
}

/// <summary>
/// Indicates whether the specified span contains <see cref="char.IsWhiteSpace(char)">any
/// white-space characters</see>.
/// </summary>
/// <param name="span">The source span.</param>
/// <returns><see langword="true"/> if the span contains any whitespace characters, <see langword="false"/> otherwise.</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool ContainsAnyWhiteSpace(this ReadOnlySpan<char> span) =>
string.SearchValuesStorage.WhiteSpaceChars.ContainsAny(span);

/// <summary>
/// Determines whether this <paramref name="span"/> and the specified <paramref name="other"/> span have the same characters
/// when compared using the specified <paramref name="comparisonType"/> option.
Expand Down Expand Up @@ -149,6 +153,24 @@ public static int IndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value
}
}

/// <summary>
/// Reports the zero-based index of the first occurrence of <see cref="char.IsWhiteSpace(char)">any white-space
/// characters</see> in the current <paramref name="span"/>, or -1 if not founded.
/// </summary>
/// <param name="span">The source span.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int IndexOfAnyWhiteSpace(this ReadOnlySpan<char> span) =>
string.SearchValuesStorage.WhiteSpaceChars.IndexOfAny(span);

/// <summary>
/// Reports the zero-based index of the first occurrence of <see cref="char.IsWhiteSpace(char)">any
/// non-white-space characters</see> in the current <paramref name="span"/>, or -1 if not founded.
/// </summary>
/// <param name="span">The source span.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int IndexOfAnyExceptWhiteSpace(this ReadOnlySpan<char> span) =>
string.SearchValuesStorage.WhiteSpaceChars.IndexOfAnyExcept(span);

/// <summary>
/// Reports the zero-based index of the last occurrence of the specified <paramref name="value"/> in the current <paramref name="span"/>.
/// </summary>
Expand Down Expand Up @@ -184,6 +206,24 @@ ref MemoryMarshal.GetReference(value),
}
}

/// <summary>
/// Reports the zero-based index of the last occurrence of <see cref="char.IsWhiteSpace(char)">any white-space
/// characters</see> in the current <paramref name="span"/>, or -1 if not founded.
/// </summary>
/// <param name="span">The source span.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int LastIndexOfAnyWhiteSpace(this ReadOnlySpan<char> span) =>
string.SearchValuesStorage.WhiteSpaceChars.LastIndexOfAny(span);

/// <summary>
/// Reports the zero-based index of the last occurrence of <see cref="char.IsWhiteSpace(char)">any
/// non-white-space characters</see> in the current <paramref name="span"/>, or -1 if not founded.
/// </summary>
/// <param name="span">The source span.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int LastIndexOfAnyExceptWhiteSpace(this ReadOnlySpan<char> span) =>
string.SearchValuesStorage.WhiteSpaceChars.LastIndexOfAnyExcept(span);

/// <summary>
/// Copies the characters from the source span into the destination, converting each character to lowercase,
/// using the casing rules of the specified culture.
Expand Down
Loading