Fix stuff from rebase

Author: zachs18

library/alloc/src/str.rs

@@ -53,7 +53,7 @@ use crate::alloc::{Allocator, Global};
 use crate::borrow::ToOwned;
 use crate::boxed::Box;
 use crate::slice::{Concat, Join, SliceIndex};
-use crate::string::String;
+use crate::string::string::String;
 use crate::vec::Vec;
 
 /// Note: `str` in `Concat<str>` is not meaningful here.

library/alloc/src/string.rs

@@ -461,7 +461,8 @@ impl<T: fmt::Display + ?Sized> SpecToString for T {
     #[inline]
     default fn spec_to_string(&self) -> String {
         let mut buf = String::new();
-        let mut formatter = core::fmt::Formatter::new(&mut buf);
+        let mut formatter =
+            core::fmt::Formatter::new(&mut buf, core::fmt::FormattingOptions::new());
         // Bypass format_args!() to avoid write_str with zero-length strs
         fmt::Display::fmt(self, &mut formatter)
             .expect("a Display implementation returned an error unexpectedly");
@@ -614,7 +615,7 @@ impl SpecToString for fmt::Arguments<'_> {
 /// [`char`]: prim@char
 /// [`into_chars`]: String::into_chars
 #[unstable(feature = "string_into_chars", issue = "133125")]
-pub type struct IntoChars = string::IntoChars<Global>;
+pub type IntoChars = string::IntoChars<Global>;
 
 /// A draining iterator for `String`.
 ///

library/alloc/src/string/string.rs

@@ -20,18 +20,18 @@ use core::ops::{self, Range, RangeBounds};
 use core::ops::{Add, AddAssign};
 use core::ptr;
 use core::slice;
-use core::str::pattern::Pattern;
+use core::str::pattern::{Pattern, Utf8Pattern};
 
 use crate::alloc::{Allocator, Global};
 #[cfg(not(no_global_oom_handling))]
 use crate::borrow::{Cow, ToOwned};
 use crate::boxed::Box;
 use crate::collections::TryReserveError;
-use crate::str::{self, from_utf8_unchecked_mut, Chars, Utf8Error};
+use crate::str::{self, from_utf8_unchecked_mut, CharIndices, Chars, Utf8Error};
 #[cfg(not(no_global_oom_handling))]
 use crate::str::{from_boxed_utf8_unchecked, FromStr};
 use crate::string::ToString;
-use crate::vec::Vec;
+use crate::vec::{self, Vec};
 
 /// A UTF-8–encoded, growable string, with allocator support.
 ///
@@ -491,6 +491,37 @@ impl<A: Allocator> String<A> {
     pub fn allocator(&self) -> &A {
         self.vec.allocator()
     }
+
+    fn from_utf8_lossy_in(v: &[u8], alloc: A) -> Result<&str, String<A>> {
+        let mut iter = v.utf8_chunks();
+
+        let first_valid = if let Some(chunk) = iter.next() {
+            let valid = chunk.valid();
+            if chunk.invalid().is_empty() {
+                debug_assert_eq!(valid.len(), v.len());
+                return Ok(valid);
+            }
+            valid
+        } else {
+            return Ok("");
+        };
+
+        const REPLACEMENT: &str = "\u{FFFD}";
+
+        let mut res = String::with_capacity_in(v.len(), alloc);
+        res.push_str(first_valid);
+        res.push_str(REPLACEMENT);
+
+        for chunk in iter {
+            res.push_str(chunk.valid());
+            if !chunk.invalid().is_empty() {
+                res.push_str(REPLACEMENT);
+            }
+        }
+
+        Err(res)
+    }
+
 }
 
 impl String {
@@ -547,42 +578,12 @@ impl String {
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str> {
-        match String::from_utf8_lossy_in(Global) {
+        match String::from_utf8_lossy_in(v, Global) {
             Ok(s) => Cow::Borrowed(s),
             Err(s) => Cow::Owned(s),
         }
     }
 
-    fn from_utf8_lossy_in(v: &[u8], alloc: A) -> Result<&str, String<A>> {
-        let mut iter = v.utf8_chunks();
-
-        let first_valid = if let Some(chunk) = iter.next() {
-            let valid = chunk.valid();
-            if chunk.invalid().is_empty() {
-                debug_assert_eq!(valid.len(), v.len());
-                return Ok(valid);
-            }
-            valid
-        } else {
-            return Ok("");
-        };
-
-        const REPLACEMENT: &str = "\u{FFFD}";
-
-        let mut res = String::with_capacity_in(v.len(), alloc);
-        res.push_str(first_valid);
-        res.push_str(REPLACEMENT);
-
-        for chunk in iter {
-            res.push_str(chunk.valid());
-            if !chunk.invalid().is_empty() {
-                res.push_str(REPLACEMENT);
-            }
-        }
-
-        Err(res)
-    }
-
     /// Converts a [`Vec<u8>`] to a `String`, substituting invalid UTF-8
     /// sequences with replacement characters.
     ///