Add String::make_(lower|upper)case APIs

Author: krtab

library/alloc/src/lib.rs

@@ -147,6 +147,7 @@
 #![feature(slice_ptr_get)]
 #![feature(slice_range)]
 #![feature(std_internals)]
+#![feature(str_internals)]
 #![feature(temporary_niche_types)]
 #![feature(titlecase)]
 #![feature(transmutability)]

library/alloc/src/str.rs

@@ -333,155 +333,6 @@ impl str {
         result
     }
 
-    /// Returns the lowercase equivalent of this string slice, as a new [`String`].
-    ///
-    /// 'Lowercase' is defined according to the terms of the Unicode Derived Core Property
-    /// `Lowercase`.
-    ///
-    /// Since some characters can expand into multiple characters when changing
-    /// the case, this function returns a [`String`] instead of modifying the
-    /// parameter in-place.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = "HELLO";
-    ///
-    /// assert_eq!("hello", s.to_lowercase());
-    /// ```
-    ///
-    /// A tricky example, with sigma:
-    ///
-    /// ```
-    /// let sigma = "Σ";
-    ///
-    /// assert_eq!("σ", sigma.to_lowercase());
-    ///
-    /// // but at the end of a word, it's ς, not σ:
-    /// let odysseus = "ὈΔΥΣΣΕΎΣ";
-    ///
-    /// assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());
-    /// ```
-    ///
-    /// Languages without case are not changed:
-    ///
-    /// ```
-    /// let new_year = "农历新年";
-    ///
-    /// assert_eq!(new_year, new_year.to_lowercase());
-    /// ```
-    #[cfg(not(no_global_oom_handling))]
-    #[rustc_allow_incoherent_impl]
-    #[must_use = "this returns the lowercase string as a new String, \
-                  without modifying the original"]
-    #[stable(feature = "unicode_case_mapping", since = "1.2.0")]
-    pub fn to_lowercase(&self) -> String {
-        let (mut s, rest) = convert_while_ascii(self, u8::to_ascii_lowercase);
-
-        let prefix_len = s.len();
-
-        for (i, c) in rest.char_indices() {
-            if c == 'Σ' {
-                // Σ maps to σ, except at the end of a word where it maps to ς.
-                // This is the only conditional (contextual) but language-independent mapping
-                // in `SpecialCasing.txt`,
-                // so hard-code it rather than have a generic "condition" mechanism.
-                // See https://github.com/rust-lang/rust/issues/26035
-                let sigma_lowercase = map_uppercase_sigma(self, prefix_len + i);
-                s.push(sigma_lowercase);
-            } else {
-                match conversions::to_lower(c) {
-                    [a, '\0', _] => s.push(a),
-                    [a, b, '\0'] => {
-                        s.push(a);
-                        s.push(b);
-                    }
-                    [a, b, c] => {
-                        s.push(a);
-                        s.push(b);
-                        s.push(c);
-                    }
-                }
-            }
-        }
-        return s;
-
-        fn map_uppercase_sigma(from: &str, i: usize) -> char {
-            // See https://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992
-            // for the definition of `Final_Sigma`.
-            let is_word_final = case_ignorable_then_cased(from[..i].chars().rev())
-                && !case_ignorable_then_cased(from[i + const { 'Σ'.len_utf8() }..].chars());
-            if is_word_final { 'ς' } else { 'σ' }
-        }
-
-        fn case_ignorable_then_cased<I: Iterator<Item = char>>(iter: I) -> bool {
-            match iter.skip_while(|&c| c.is_case_ignorable()).next() {
-                Some(c) => c.is_cased(),
-                None => false,
-            }
-        }
-    }
-
-    /// Returns the uppercase equivalent of this string slice, as a new [`String`].
-    ///
-    /// 'Uppercase' is defined according to the terms of the Unicode Derived Core Property
-    /// `Uppercase`.
-    ///
-    /// Since some characters can expand into multiple characters when changing
-    /// the case, this function returns a [`String`] instead of modifying the
-    /// parameter in-place.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = "hello";
-    ///
-    /// assert_eq!("HELLO", s.to_uppercase());
-    /// ```
-    ///
-    /// Scripts without case are not changed:
-    ///
-    /// ```
-    /// let new_year = "农历新年";
-    ///
-    /// assert_eq!(new_year, new_year.to_uppercase());
-    /// ```
-    ///
-    /// One character can become multiple:
-    /// ```
-    /// let s = "tschüß";
-    ///
-    /// assert_eq!("TSCHÜSS", s.to_uppercase());
-    /// ```
-    #[cfg(not(no_global_oom_handling))]
-    #[rustc_allow_incoherent_impl]
-    #[must_use = "this returns the uppercase string as a new String, \
-                  without modifying the original"]
-    #[stable(feature = "unicode_case_mapping", since = "1.2.0")]
-    pub fn to_uppercase(&self) -> String {
-        let (mut s, rest) = convert_while_ascii(self, u8::to_ascii_uppercase);
-
-        for c in rest.chars() {
-            match conversions::to_upper(c) {
-                [a, '\0', _] => s.push(a),
-                [a, b, '\0'] => {
-                    s.push(a);
-                    s.push(b);
-                }
-                [a, b, c] => {
-                    s.push(a);
-                    s.push(b);
-                    s.push(c);
-                }
-            }
-        }
-        s
-    }
-
     /// Converts a [`Box<str>`] into a [`String`] without copying or allocating.
     ///
     /// # Examples
@@ -710,3 +561,156 @@ unsafe fn replace_ascii(utf8_bytes: &[u8], from: u8, to: u8) -> String {
     // SAFETY: We replaced ascii with ascii on valid utf8 strings.
     unsafe { String::from_utf8_unchecked(result) }
 }
+
+// Case changes
+
+pub(crate) fn case_ignorable_then_cased<I: Iterator<Item = char>>(iter: I) -> bool {
+    match iter.skip_while(|&c| c.is_case_ignorable()).next() {
+        Some(c) => c.is_cased(),
+        None => false,
+    }
+}
+
+impl str {
+    /// Returns the lowercase equivalent of this string slice, as a new [`String`].
+    ///
+    /// 'Lowercase' is defined according to the terms of the Unicode Derived Core Property
+    /// `Lowercase`.
+    ///
+    /// Since some characters can expand into multiple characters when changing
+    /// the case, this function returns a [`String`] instead of modifying the
+    /// parameter in-place.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// let s = "HELLO";
+    ///
+    /// assert_eq!("hello", s.to_lowercase());
+    /// ```
+    ///
+    /// A tricky example, with sigma:
+    ///
+    /// ```
+    /// let sigma = "Σ";
+    ///
+    /// assert_eq!("σ", sigma.to_lowercase());
+    ///
+    /// // but at the end of a word, it's ς, not σ:
+    /// let odysseus = "ὈΔΥΣΣΕΎΣ";
+    ///
+    /// assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());
+    /// ```
+    ///
+    /// Languages without case are not changed:
+    ///
+    /// ```
+    /// let new_year = "农历新年";
+    ///
+    /// assert_eq!(new_year, new_year.to_lowercase());
+    /// ```
+    #[cfg(not(no_global_oom_handling))]
+    #[rustc_allow_incoherent_impl]
+    #[must_use = "this returns the lowercase string as a new String, \
+                  without modifying the original"]
+    #[stable(feature = "unicode_case_mapping", since = "1.2.0")]
+    pub fn to_lowercase(&self) -> String {
+        let (mut s, rest) = convert_while_ascii(self, u8::to_ascii_lowercase);
+
+        let prefix_len = s.len();
+
+        for (i, c) in rest.char_indices() {
+            if c == 'Σ' {
+                // Σ maps to σ, except at the end of a word where it maps to ς.
+                // This is the only conditional (contextual) but language-independent mapping
+                // in `SpecialCasing.txt`,
+                // so hard-code it rather than have a generic "condition" mechanism.
+                // See https://github.com/rust-lang/rust/issues/26035
+                let sigma_lowercase = map_uppercase_sigma(self, prefix_len + i);
+                s.push(sigma_lowercase);
+            } else {
+                match conversions::to_lower(c) {
+                    [a, '\0', _] => s.push(a),
+                    [a, b, '\0'] => {
+                        s.push(a);
+                        s.push(b);
+                    }
+                    [a, b, c] => {
+                        s.push(a);
+                        s.push(b);
+                        s.push(c);
+                    }
+                }
+            }
+        }
+        return s;
+
+        fn map_uppercase_sigma(from: &str, i: usize) -> char {
+            // See https://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992
+            // for the definition of `Final_Sigma`.
+            let is_word_final = case_ignorable_then_cased(from[..i].chars().rev())
+                && !case_ignorable_then_cased(from[i + const { 'Σ'.len_utf8() }..].chars());
+            if is_word_final { 'ς' } else { 'σ' }
+        }
+    }
+
+    /// Returns the uppercase equivalent of this string slice, as a new [`String`].
+    ///
+    /// 'Uppercase' is defined according to the terms of the Unicode Derived Core Property
+    /// `Uppercase`.
+    ///
+    /// Since some characters can expand into multiple characters when changing
+    /// the case, this function returns a [`String`] instead of modifying the
+    /// parameter in-place.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// let s = "hello";
+    ///
+    /// assert_eq!("HELLO", s.to_uppercase());
+    /// ```
+    ///
+    /// Scripts without case are not changed:
+    ///
+    /// ```
+    /// let new_year = "农历新年";
+    ///
+    /// assert_eq!(new_year, new_year.to_uppercase());
+    /// ```
+    ///
+    /// One character can become multiple:
+    /// ```
+    /// let s = "tschüß";
+    ///
+    /// assert_eq!("TSCHÜSS", s.to_uppercase());
+    /// ```
+    #[cfg(not(no_global_oom_handling))]
+    #[rustc_allow_incoherent_impl]
+    #[must_use = "this returns the uppercase string as a new String, \
+                  without modifying the original"]
+    #[stable(feature = "unicode_case_mapping", since = "1.2.0")]
+    pub fn to_uppercase(&self) -> String {
+        let (mut s, rest) = convert_while_ascii(self, u8::to_ascii_uppercase);
+
+        for c in rest.chars() {
+            match conversions::to_upper(c) {
+                [a, '\0', _] => s.push(a),
+                [a, b, '\0'] => {
+                    s.push(a);
+                    s.push(b);
+                }
+                [a, b, c] => {
+                    s.push(a);
+                    s.push(b);
+                    s.push(c);
+                }
+            }
+        }
+        s
+    }
+}