Add methods from #27912 (Flow System.Text.Rune through more APIs)

src/libraries/System.Private.CoreLib/src/System/Char.cs

@@ -129,6 +129,19 @@ public bool Equals(char obj)
             return m_value == obj;
         }
 
+        internal bool Equals(char right, StringComparison comparisonType)
+        {
+            switch (comparisonType)
+            {
+                case StringComparison.Ordinal:
+                    return Equals(right);
+                default:
+                    ReadOnlySpan<char> leftCharsSlice = [this];
+                    ReadOnlySpan<char> rightCharsSlice = [right];
+                    return leftCharsSlice.Equals(rightCharsSlice, comparisonType);
+            }
+        }
+
         // Compares this object to another object, returning an integer that
         // indicates the relationship.
         // Returns a value less than zero if this  object

src/libraries/System.Private.CoreLib/src/System/Globalization/TextInfo.cs

@@ -180,6 +180,17 @@ public string ToLower(string str)
             return ChangeCaseCommon<ToLowerConversion>(str);
         }
 
+        internal void ToLower(ReadOnlySpan<char> source, Span<char> destination)
+        {
+            if (GlobalizationMode.Invariant)
+            {
+                InvariantModeCasing.ToLower(source, destination);
+                return;
+            }
+
+            ChangeCaseCommon<ToLowerConversion>(source, destination);
+        }
+
         private unsafe char ChangeCase(char c, bool toUpper)
         {
             Debug.Assert(!GlobalizationMode.Invariant);
@@ -451,6 +462,17 @@ public string ToUpper(string str)
             return ChangeCaseCommon<ToUpperConversion>(str);
         }
 
+        internal void ToUpper(ReadOnlySpan<char> source, Span<char> destination)
+        {
+            if (GlobalizationMode.Invariant)
+            {
+                InvariantModeCasing.ToUpper(source, destination);
+                return;
+            }
+
+            ChangeCaseCommon<ToUpperConversion>(source, destination);
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static char ToUpperAsciiInvariant(char c)
         {
@@ -461,6 +483,46 @@ internal static char ToUpperAsciiInvariant(char c)
             return c;
         }
 
+        public Rune ToLower(Rune value)
+        {
+            // Convert rune to span
+            Span<char> chars = stackalloc char[2];
+            int charsWritten = value.EncodeToUtf16(chars);
+
+            // Change span to lower and convert to rune
+            if (charsWritten == 2)
+            {
+                Span<char> lowerChars = stackalloc char[2];
+                ToLower(chars, lowerChars);
+                return new Rune(lowerChars[0], lowerChars[1]);
+            }
+            else
+            {
+                char lowerChar = ToLower(chars[0]);
+                return new Rune(lowerChar);
+            }
+        }
+
+        public Rune ToUpper(Rune value)
+        {
+            // Convert rune to span
+            Span<char> chars = stackalloc char[2];
+            int charsWritten = value.EncodeToUtf16(chars);
+
+            // Change span to upper and convert to rune
+            if (charsWritten == 2)
+            {
+                Span<char> upperChars = stackalloc char[2];
+                ToUpper(chars, upperChars);
+                return new Rune(upperChars[0], upperChars[1]);
+            }
+            else
+            {
+                char upperChar = ToUpper(chars[0]);
+                return new Rune(upperChar);
+            }
+        }
+
         private bool IsAsciiCasingSameAsInvariant
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/libraries/System.Private.CoreLib/src/System/IO/TextWriter.cs

@@ -125,6 +125,20 @@ public virtual void Write(char value)
         {
         }
 
+        public virtual void Write(Rune value)
+        {
+            // Convert value to span
+            Span<char> chars = stackalloc char[2];
+            int charsWritten = value.EncodeToUtf16(chars);
+
+            // Write span
+            Write(chars[0]);
+            if (charsWritten > 1)
+            {
+                Write(chars[1]);
+            }
+        }
+
         // Writes a character array to the text stream. This default method calls
         // Write(char) for each of the characters in the character array.
         // If the character array is null, nothing is written.
@@ -343,6 +357,23 @@ public virtual void WriteLine(char value)
             WriteLine();
         }
 
+        public virtual void WriteLine(Rune value)
+        {
+            // Convert value to span
+            Span<char> chars = stackalloc char[2];
+            int charsWritten = value.EncodeToUtf16(chars);
+
+            if (charsWritten > 1)
+            {
+                Write(chars[0]);
+                WriteLine(chars[1]);
+            }
+            else
+            {
+                WriteLine(chars[0]);
+            }
+        }
+
         // Writes an array of characters followed by a line terminator to the text
         // stream.
         //
@@ -542,6 +573,24 @@ public virtual Task WriteAsync(char value) =>
                 t.Item1.Write(t.Item2);
             }, new TupleSlim<TextWriter, char>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
 
+        public virtual Task WriteAsync(Rune value)
+        {
+            Span<char> chars = stackalloc char[2];
+            int charsWritten = value.EncodeToUtf16(chars);
+
+            if (charsWritten > 1)
+            {
+                return Task.Factory.StartNew(static state =>
+                {
+                    var t = (TupleSlim<TextWriter, char, char>)state!;
+                    t.Item1.Write(t.Item2);
+                    t.Item1.Write(t.Item3);
+                }, new TupleSlim<TextWriter, char, char>(this, chars[0], chars[1]), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
+            }
+
+            return WriteAsync(chars[0]);
+        }
+
         public virtual Task WriteAsync(string? value) =>
             Task.Factory.StartNew(static state =>
             {
@@ -605,6 +654,24 @@ public virtual Task WriteLineAsync(char value) =>
                 t.Item1.WriteLine(t.Item2);
             }, new TupleSlim<TextWriter, char>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
 
+        public virtual Task WriteLineAsync(Rune value)
+        {
+            Span<char> chars = stackalloc char[2];
+            int charsWritten = value.EncodeToUtf16(chars);
+
+            if (charsWritten > 1)
+            {
+                return Task.Factory.StartNew(static state =>
+                {
+                    var t = (TupleSlim<TextWriter, char, char>)state!;
+                    t.Item1.Write(t.Item2);
+                    t.Item1.WriteLine(t.Item3);
+                }, new TupleSlim<TextWriter, char, char>(this, chars[0], chars[1]), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
+            }
+
+            return WriteAsync(chars[0]);
+        }
+
         public virtual Task WriteLineAsync(string? value) =>
             Task.Factory.StartNew(static state =>
             {

src/libraries/System.Private.CoreLib/src/System/String.Comparison.cs

@@ -9,6 +9,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Text;
 using System.Text.Unicode;
 
 namespace System
@@ -589,6 +590,29 @@ public bool EndsWith(char value)
             return ((uint)lastPos < (uint)Length) && this[lastPos] == value;
         }
 
+        public bool EndsWith(char value, StringComparison comparisonType)
+        {
+            if (Length == 0)
+            {
+                return false;
+            }
+            return this[^1].Equals(value, comparisonType);
+        }
+
+        public bool EndsWith(Rune value)
+        {
+            return EndsWith(value, StringComparison.Ordinal);
+        }
+
+        public bool EndsWith(Rune value, StringComparison comparisonType)
+        {
+            if (Rune.DecodeLastFromUtf16(this, out Rune result, out _) is OperationStatus.Done)
+            {
+                return result.Equals(value, comparisonType);
+            }
+            return false;
+        }
+
         // Determines whether two strings match.
         public override bool Equals([NotNullWhen(true)] object? obj)
         {
@@ -1162,6 +1186,29 @@ public bool StartsWith(char value)
             return Length != 0 && _firstChar == value;
         }
 
+        public bool StartsWith(char value, StringComparison comparisonType)
+        {
+            if (this.Length == 0)
+            {
+                return false;
+            }
+            return this[0].Equals(value, comparisonType);
+        }
+
+        public bool StartsWith(Rune value)
+        {
+            return StartsWith(value, StringComparison.Ordinal);
+        }
+
+        public bool StartsWith(Rune value, StringComparison comparisonType)
+        {
+            if (Rune.DecodeFromUtf16(this, out Rune result, out _) is OperationStatus.Done)
+            {
+                return result.Equals(value, comparisonType);
+            }
+            return false;
+        }
+
         internal static void CheckStringComparison(StringComparison comparisonType)
         {
             // Single comparison to check if comparisonType is within [CurrentCulture .. OrdinalIgnoreCase]