Remove GetAsciiCore/GetUnicodeCore indirection, inline directly into callers

Co-authored-by: jkotas <[email protected]>

Author: Copilot

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

@@ -75,46 +75,40 @@ public string GetAscii(string unicode, int index, int count)
             if (index > unicode.Length - count)
                 throw new ArgumentOutOfRangeException(nameof(unicode), SR.ArgumentOutOfRange_IndexCountBuffer);
 
-            return GetAsciiCore(unicode, unicode.AsSpan(index, count));
-        }
-
-        /// <summary>
-        /// Encodes a substring of domain name labels that include Unicode characters outside the ASCII character range (U+0000 to U+007F) to a displayable Unicode string.
-        /// </summary>
-        /// <param name="unicode">The Unicode domain name to convert.</param>
-        /// <param name="destination">The buffer to write the ASCII result to.</param>
-        /// <param name="charsWritten">When this method returns, contains the number of characters that were written to <paramref name="destination"/>.</param>
-        /// <returns><see langword="true"/> if the conversion was successful and the result was written to <paramref name="destination"/>; otherwise, <see langword="false"/> if <paramref name="destination"/> is too small to contain the result.</returns>
-        /// <exception cref="ArgumentException"><paramref name="unicode"/> is invalid based on the <see cref="AllowUnassigned"/> and <see cref="UseStd3AsciiRules"/> properties, and the IDNA standard.</exception>
-        public bool TryGetAscii(ReadOnlySpan<char> unicode, Span<char> destination, out int charsWritten)
-        {
-            if (unicode.Length == 0)
+            if (count == 0)
             {
                 throw new ArgumentException(SR.Argument_IdnBadLabelSize, nameof(unicode));
             }
-            if (unicode[^1] == 0)
+            if (unicode[index + count - 1] == 0)
             {
-                throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequence, unicode.Length - 1), nameof(unicode));
+                throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequence, index + count - 1), nameof(unicode));
             }
 
             if (GlobalizationMode.Invariant)
             {
-                return TryGetAsciiInvariant(unicode, destination, out charsWritten);
+                return GetAsciiInvariant(unicode.AsSpan(index, count));
             }
 
             unsafe
             {
-                fixed (char* pUnicode = &MemoryMarshal.GetReference(unicode))
-                fixed (char* pDestination = &MemoryMarshal.GetReference(destination))
+                fixed (char* pUnicode = unicode)
                 {
                     return GlobalizationMode.UseNls ?
-                        NlsTryGetAsciiCore(pUnicode, unicode.Length, pDestination, destination.Length, out charsWritten) :
-                        IcuTryGetAsciiCore(pUnicode, unicode.Length, pDestination, destination.Length, out charsWritten);
+                        NlsGetAsciiCore(unicode, pUnicode + index, count) :
+                        IcuGetAsciiCore(unicode, pUnicode + index, count);
                 }
             }
         }
 
-        private string GetAsciiCore(string? originalUnicode, ReadOnlySpan<char> unicode)
+        /// <summary>
+        /// Encodes a substring of domain name labels that include Unicode characters outside the ASCII character range (U+0000 to U+007F) to a displayable Unicode string.
+        /// </summary>
+        /// <param name="unicode">The Unicode domain name to convert.</param>
+        /// <param name="destination">The buffer to write the ASCII result to.</param>
+        /// <param name="charsWritten">When this method returns, contains the number of characters that were written to <paramref name="destination"/>.</param>
+        /// <returns><see langword="true"/> if the conversion was successful and the result was written to <paramref name="destination"/>; otherwise, <see langword="false"/> if <paramref name="destination"/> is too small to contain the result.</returns>
+        /// <exception cref="ArgumentException"><paramref name="unicode"/> is invalid based on the <see cref="AllowUnassigned"/> and <see cref="UseStd3AsciiRules"/> properties, and the IDNA standard.</exception>
+        public bool TryGetAscii(ReadOnlySpan<char> unicode, Span<char> destination, out int charsWritten)
         {
             if (unicode.Length == 0)
             {
@@ -127,16 +121,17 @@ private string GetAsciiCore(string? originalUnicode, ReadOnlySpan<char> unicode)
 
             if (GlobalizationMode.Invariant)
             {
-                return GetAsciiInvariant(unicode);
+                return TryGetAsciiInvariant(unicode, destination, out charsWritten);
             }
 
             unsafe
             {
                 fixed (char* pUnicode = &MemoryMarshal.GetReference(unicode))
+                fixed (char* pDestination = &MemoryMarshal.GetReference(destination))
                 {
                     return GlobalizationMode.UseNls ?
-                        NlsGetAsciiCore(originalUnicode, pUnicode, unicode.Length) :
-                        IcuGetAsciiCore(originalUnicode, pUnicode, unicode.Length);
+                        NlsTryGetAsciiCore(pUnicode, unicode.Length, pDestination, destination.Length, out charsWritten) :
+                        IcuTryGetAsciiCore(pUnicode, unicode.Length, pDestination, destination.Length, out charsWritten);
                 }
             }
         }
@@ -166,7 +161,23 @@ public string GetUnicode(string ascii, int index, int count)
             // This is a case (i.e. explicitly null-terminated input) where behavior in .NET and Win32 intentionally differ.
             // The .NET APIs should (and did in v4.0 and earlier) throw an ArgumentException on input that includes a terminating null.
             // The Win32 APIs fail on an embedded null, but not on a terminating null.
-            return GetUnicodeCore(ascii, ascii.AsSpan(index, count));
+            if (count > 0 && ascii[index + count - 1] == (char)0)
+                throw new ArgumentException(SR.Argument_IdnBadPunycode, nameof(ascii));
+
+            if (GlobalizationMode.Invariant)
+            {
+                return GetUnicodeInvariant(ascii.AsSpan(index, count));
+            }
+
+            unsafe
+            {
+                fixed (char* pAscii = ascii)
+                {
+                    return GlobalizationMode.UseNls ?
+                        NlsGetUnicodeCore(ascii, pAscii + index, count) :
+                        IcuGetUnicodeCore(ascii, pAscii + index, count);
+                }
+            }
         }
 
         /// <summary>
@@ -202,30 +213,6 @@ public bool TryGetUnicode(ReadOnlySpan<char> ascii, Span<char> destination, out
             }
         }
 
-        private string GetUnicodeCore(string? originalAscii, ReadOnlySpan<char> ascii)
-        {
-            // This is a case (i.e. explicitly null-terminated input) where behavior in .NET and Win32 intentionally differ.
-            // The .NET APIs should (and did in v4.0 and earlier) throw an ArgumentException on input that includes a terminating null.
-            // The Win32 APIs fail on an embedded null, but not on a terminating null.
-            if (ascii.Length > 0 && ascii[^1] == (char)0)
-                throw new ArgumentException(SR.Argument_IdnBadPunycode, nameof(ascii));
-
-            if (GlobalizationMode.Invariant)
-            {
-                return GetUnicodeInvariant(ascii);
-            }
-
-            unsafe
-            {
-                fixed (char* pAscii = &MemoryMarshal.GetReference(ascii))
-                {
-                    return GlobalizationMode.UseNls ?
-                        NlsGetUnicodeCore(originalAscii, pAscii, ascii.Length) :
-                        IcuGetUnicodeCore(originalAscii, pAscii, ascii.Length);
-                }
-            }
-        }
-
         public override bool Equals([NotNullWhen(true)] object? obj) =>
             obj is IdnMapping that &&
             _allowUnassigned == that._allowUnassigned &&