Remove unnecessary string.AsSpan() calls as of C# 14, apache#1340 (apache#1374)

Author: paulirwin

src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs

@@ -365,32 +365,14 @@ protected virtual void SearchPatterns(ReadOnlySpan<char> word, int index, Span<b
             }
         }
 
-        /// <summary>
-        /// Hyphenate word and return a <see cref="Hyphenation"/> object.
-        /// </summary>
-        /// <param name="word"> the word to be hyphenated </param>
-        /// <param name="remainCharCount"> Minimum number of characters allowed before the
-        ///        hyphenation point. </param>
-        /// <param name="pushCharCount"> Minimum number of characters allowed after the
-        ///        hyphenation point. </param>
-        /// <returns> a <see cref="Hyphenation"/> object representing the
-        ///         hyphenated word or null if word is not hyphenated. </returns>
-        public virtual Hyphenation Hyphenate(string word, int remainCharCount, int pushCharCount)
-        {
-            // LUCENENET: use Span instead of ToCharArray
-            return Hyphenate(word.AsSpan(), 0, word.Length, remainCharCount, pushCharCount);
-        }
-
-
-
         /// <summary>
         /// Hyphenate word and return an array of hyphenation points.
         /// </summary>
         /// <remarks>
-        /// w = "****nnllllllnnn*****", where n is a non-letter, l is a letter, all n
-        /// may be absent, the first n is at offset, the first l is at offset +
-        /// iIgnoreAtBeginning; word = ".llllll.'\0'***", where all l in w are copied
-        /// into word. In the first part of the routine len = w.length, in the second
+        /// w = "****nnllllllnnn*****".AsSpan(offset, len), where n is a non-letter,
+        /// l is a letter, all n may be absent, the first n is at offset, the first l is
+        /// at offset + iIgnoreAtBeginning; word = ".llllll.'\0'***", where all l in w are
+        /// copied into word. In the first part of the routine len = w.length, in the second
         /// part of the routine len = word.length. Three indices are used: index(w),
         /// the index in w, index(word), the index in word, letterindex(word), the
         /// index in the letter part of word. The following relations exist: index(w) =
@@ -399,18 +381,22 @@ public virtual Hyphenation Hyphenate(string word, int remainCharCount, int pushC
         /// offset - 1 + iIgnoreAtBeginning index(w) = letterindex(word) + offset +
         /// iIgnoreAtBeginning
         /// </remarks>
-        /// <param name="w"> char array that contains the word </param>
-        /// <param name="offset"> Offset to first character in word </param>
-        /// <param name="len"> Length of word </param>
-        /// <param name="remainCharCount"> Minimum number of characters allowed before the
-        ///        hyphenation point. </param>
-        /// <param name="pushCharCount"> Minimum number of characters allowed after the
-        ///        hyphenation point. </param>
-        /// <returns> a <see cref="Hyphenation"/> object representing the
-        ///         hyphenated word or null if word is not hyphenated. </returns>
-        public virtual Hyphenation Hyphenate(ReadOnlySpan<char> w, int offset, int len, int remainCharCount, int pushCharCount)
+        /// <param name="w">
+        /// <see cref="ReadOnlySpan{T}"/> that contains the word. This should be sliced
+        /// to the desired offset and length before passing in if necessary.
+        /// </param>
+        /// <param name="remainCharCount">
+        /// Minimum number of characters allowed before the hyphenation point.
+        /// </param>
+        /// <param name="pushCharCount">
+        /// Minimum number of characters allowed after the hyphenation point.
+        /// </param>
+        /// <returns>
+        /// a <see cref="Hyphenation"/> object representing the hyphenated word or null if word is not hyphenated.
+        /// </returns>
+        public virtual Hyphenation Hyphenate(ReadOnlySpan<char> w, int remainCharCount, int pushCharCount)
         {
-            int i;
+            int i, len = w.Length;
             // LUCENENET: optimized method for Span and stackalloc
             Span<char> word = (len + 3) * sizeof(char) > Constants.MaxStackByteLimit ? new char[len + 3] : stackalloc char[len + 3];
 
@@ -421,7 +407,7 @@ public virtual Hyphenation Hyphenate(ReadOnlySpan<char> w, int offset, int len,
             bool bEndOfLetters = false;
             for (i = 1; i <= len; i++)
             {
-                c[0] = w[offset + i - 1];
+                c[0] = w[i - 1];
                 int nc = m_classmap.Find(c, 0);
                 if (nc < 0) // found a non-letter character ...
                 {

src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/TernaryTree.cs

@@ -146,6 +146,7 @@ protected void Init()
         /// same prefix is inserted. This saves a lot of space, specially for long
         /// keys.
         /// </summary>
+        // LUCENENET: string overload retained here for public API for non-C#-14 callers
         public void Insert(string key, char val)
             => Insert(key.AsSpan(), val);
 

src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilter.cs

@@ -188,7 +188,7 @@ public static HyphenationTree GetHyphenationTree(Stream hyphenationSource, Encod
         protected override void Decompose()
         {
             // get the hyphenation points
-            Hyphenation.Hyphenation hyphens = hyphenator.Hyphenate(m_termAtt.Buffer, 0, m_termAtt.Length, 1, 1);
+            Hyphenation.Hyphenation hyphens = hyphenator.Hyphenate(m_termAtt.AsSpan(), 1, 1);
             // No hyphen points found -> exit
             if (hyphens is null)
             {

src/Lucene.Net.Analysis.Common/Analysis/El/GreekStemmer.cs

@@ -1004,7 +1004,7 @@ private static int Rule22(char[] s, int len) // LUCENENET: CA1822: Mark members
         /// <param name="suffix"> A <see cref="string"/> object to check if the word given ends with these characters. </param>
         /// <returns> True if the word ends with the suffix given , false otherwise. </returns>
         private static bool EndsWith(char[] s, int len, string suffix) // LUCENENET: CA1822: Mark members as static
-            => s.AsSpan(0, len).EndsWith(suffix.AsSpan()); // LUCENENET specific - optimized for ReadOnlySpan<char>
+            => s.AsSpan(0, len).EndsWith(suffix); // LUCENENET specific - optimized for ReadOnlySpan<char>
 
         /// <summary>
         /// Checks if the word contained in the leading portion of <see cref="T:char[]"/> array ,

src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs

@@ -3827,7 +3827,7 @@ internal static CharReturnType ConvertObjectToChars<T>(T key, out char[] chars,
 
 #if FEATURE_SPANFORMATTABLE
             else if (key is ISpanFormattable spanFormattable &&
-                spanFormattable.TryFormat(reuse, out int charsWritten, string.Empty.AsSpan(), invariant))
+                spanFormattable.TryFormat(reuse, out int charsWritten, ReadOnlySpan<char>.Empty, invariant))
             {
                 chars = reuse.Slice(0, charsWritten).ToArray();
                 return CharReturnType.CharArray;

src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs

@@ -38,28 +38,12 @@ public static class StemmerUtil // LUCENENET specific: CA1052 Static holder type
         /// <remarks>
         /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
         /// </remarks>
+        // LUCENENET: string overload retained here for public API for non-C#-14 callers
         public static bool StartsWith(ReadOnlySpan<char> s, string prefix)
         {
             return StartsWith(s, prefix.AsSpan());
         }
 
-        /// <summary>
-        /// Returns true if the character array starts with the prefix.
-        /// </summary>
-        /// <param name="s"> Input Buffer </param>
-        /// <param name="len"> length of input buffer </param>
-        /// <param name="prefix"> Prefix string to test </param>
-        /// <returns> <c>true</c> if <paramref name="s"/> starts with <paramref name="prefix"/> </returns>
-        /// <remarks>
-        /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
-        /// Callers should prefer the overload without the <paramref name="len"/> parameter and use a slice instead,
-        /// but this overload is provided for compatibility with existing code.
-        /// </remarks>
-        internal static bool StartsWith(ReadOnlySpan<char> s, int len, string prefix)
-        {
-            return StartsWith(s.Slice(0, len), prefix.AsSpan());
-        }
-
         /// <summary>
         /// Returns true if the character array starts with the prefix.
         /// </summary>
@@ -107,28 +91,12 @@ internal static bool StartsWith(ReadOnlySpan<char> s, int len, ReadOnlySpan<char
         /// <remarks>
         /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
         /// </remarks>
+        // LUCENENET: string overload retained here for public API for non-C#-14 callers
         public static bool EndsWith(ReadOnlySpan<char> s, string suffix)
         {
             return EndsWith(s, suffix.AsSpan());
         }
 
-        /// <summary>
-        /// Returns true if the character array ends with the suffix.
-        /// </summary>
-        /// <param name="s"> Input Buffer </param>
-        /// <param name="len"> length of input buffer </param>
-        /// <param name="suffix"> Suffix string to test </param>
-        /// <returns> <c>true</c> if <paramref name="s"/> ends with <paramref name="suffix"/> </returns>
-        /// <remarks>
-        /// LUCENENET NOTE: This method has been converted to use <see cref="ReadOnlySpan{T}"/>.
-        /// Callers should prefer the overload without the <paramref name="len"/> parameter and use a slice instead,
-        /// but this overload is provided for compatibility with existing code.
-        /// </remarks>
-        internal static bool EndsWith(ReadOnlySpan<char> s, int len, string suffix)
-        {
-            return EndsWith(s.Slice(0, len), suffix.AsSpan());
-        }
-
         /// <summary>
         /// Returns true if the character array ends with the suffix.
         /// </summary>

src/Lucene.Net.Analysis.Kuromoji/JapaneseReadingFormFilter.cs

@@ -69,7 +69,7 @@ public override bool IncrementToken()
                     else
                     {
                         buffer.Length = 0;
-                        ToStringUtil.GetRomanization(buffer, reading.AsSpan());
+                        ToStringUtil.GetRomanization(buffer, reading);
                         termAttr.SetEmpty().Append(buffer);
                     }
                 }

src/Lucene.Net.Analysis.Kuromoji/TokenAttributes/ReadingAttributeImpl.cs

@@ -67,9 +67,9 @@ public override void ReflectWith(IAttributeReflector reflector)
                 throw new ArgumentNullException(nameof(reflector));
 
             string? reading = GetReading();
-            string? readingEN = reading is null ? null : ToStringUtil.GetRomanization(reading.AsSpan());
+            string? readingEN = reading is null ? null : ToStringUtil.GetRomanization(reading);
             string? pronunciation = GetPronunciation();
-            string? pronunciationEN = pronunciation is null ? null : ToStringUtil.GetRomanization(pronunciation.AsSpan());
+            string? pronunciationEN = pronunciation is null ? null : ToStringUtil.GetRomanization(pronunciation);
             reflector.Reflect<IReadingAttribute>("reading", reading);
             reflector.Reflect<IReadingAttribute>("reading (en)", readingEN);
             reflector.Reflect<IReadingAttribute>("pronunciation", pronunciation);

src/Lucene.Net.Analysis.Phonetic/Language/Bm/Rule.cs

@@ -636,41 +636,41 @@ private static IRPattern GetPattern(string regex)
                             // exact match
                             return new RPatternHelper(isMatchSB: (input) =>
                             {
-                                return input.Length == 1 && Contains(bContent.AsSpan(), input[0]) == shouldMatch;
+                                return input.Length == 1 && Contains(bContent, input[0]) == shouldMatch;
                             }, isMatchStr: (input) =>
                             {
-                                return input.Length == 1 && Contains(bContent.AsSpan(), input[0]) == shouldMatch;
+                                return input.Length == 1 && Contains(bContent, input[0]) == shouldMatch;
                             }, isMatchCS: (input) =>
                             {
-                                return input.Length == 1 && Contains(bContent.AsSpan(), input[0]) == shouldMatch;
+                                return input.Length == 1 && Contains(bContent, input[0]) == shouldMatch;
                             });
                         }
                         else if (startsWith)
                         {
                             // first char
                             return new RPatternHelper(isMatchSB: (input) =>
                             {
-                                return input.Length > 0 && Contains(bContent.AsSpan(), input[0]) == shouldMatch;
+                                return input.Length > 0 && Contains(bContent, input[0]) == shouldMatch;
                             }, isMatchStr: (input) =>
                             {
-                                return input.Length > 0 && Contains(bContent.AsSpan(), input[0]) == shouldMatch;
+                                return input.Length > 0 && Contains(bContent, input[0]) == shouldMatch;
                             }, isMatchCS: (input) =>
                             {
-                                return input.Length > 0 && Contains(bContent.AsSpan(), input[0]) == shouldMatch;
+                                return input.Length > 0 && Contains(bContent, input[0]) == shouldMatch;
                             });
                         }
                         else if (endsWith)
                         {
                             // last char
                             return new RPatternHelper(isMatchSB: (input) =>
                             {
-                                return input.Length > 0 && Contains(bContent.AsSpan(), input[input.Length - 1]) == shouldMatch;
+                                return input.Length > 0 && Contains(bContent, input[input.Length - 1]) == shouldMatch;
                             }, isMatchStr: (input) =>
                             {
-                                return input.Length > 0 && Contains(bContent.AsSpan(), input[input.Length - 1]) == shouldMatch;
+                                return input.Length > 0 && Contains(bContent, input[input.Length - 1]) == shouldMatch;
                             }, isMatchCS: (input) =>
                             {
-                                return input.Length > 0 && Contains(bContent.AsSpan(), input[input.Length - 1]) == shouldMatch;
+                                return input.Length > 0 && Contains(bContent, input[input.Length - 1]) == shouldMatch;
                             });
                         }
                     }

src/Lucene.Net.Facet/Taxonomy/WriterCache/CategoryPathUtils.cs

@@ -90,7 +90,7 @@ public static bool EqualsToSerialized(FacetLabel cp, CharBlockArray charBlockArr
                 }
 
                 // LUCENENET specific - calculate the hash code without the allocation caused by Subsequence() and ToString()
-                if (!charBlockArray.Equals(offset, len, cp.Components[i].AsSpan())) // LUCENENET: Corrected 2nd parameter
+                if (!charBlockArray.Equals(offset, len, cp.Components[i])) // LUCENENET: Corrected 2nd parameter
                 {
                     return false;
                 }