Rollup merge of rust-lang#52732 - SimonSapin:spring, r=Mark-Simulacrum

Remove unstable and deprecated APIs

src/Cargo.lock

@@ -2612,18 +2612,9 @@ dependencies = [
  "rustc_lsan 0.0.0",
  "rustc_msan 0.0.0",
  "rustc_tsan 0.0.0",
- "std_unicode 0.0.0",
  "unwind 0.0.0",
 ]
 
-[[package]]
-name = "std_unicode"
-version = "0.0.0"
-dependencies = [
- "compiler_builtins 0.0.0",
- "core 0.0.0",
-]
-
 [[package]]
 name = "string_cache"
 version = "0.7.3"

src/bootstrap/compile.rs

@@ -157,7 +157,6 @@ pub fn std_cargo(builder: &Builder,
  cargo.arg("--features").arg("c mem")
  .args(&["-p", "alloc"])
  .args(&["-p", "compiler_builtins"])
- .args(&["-p", "std_unicode"])
  .arg("--manifest-path")
  .arg(builder.src.join("src/rustc/compiler_builtins_shim/Cargo.toml"));
  } else {

src/bootstrap/dist.rs

@@ -856,7 +856,6 @@ impl Step for Src {
  "src/librustc_msan",
  "src/librustc_tsan",
  "src/libstd",
- "src/libstd_unicode",
  "src/libunwind",
  "src/rustc/compiler_builtins_shim",
  "src/rustc/libc_shim",

src/bootstrap/doc.rs

@@ -489,7 +489,7 @@ impl Step for Std {
  // Keep a whitelist so we do not build internal stdlib crates, these will be
  // build by the rustc step later if enabled.
  cargo.arg("--no-deps");
- for krate in &["alloc", "core", "std", "std_unicode"] {
+ for krate in &["alloc", "core", "std"] {
  cargo.arg("-p").arg(krate);
  // Create all crate output directories first to make sure rustdoc uses
  // relative links.

src/libcore/char/decode.rs

@@ -11,135 +11,8 @@
 //! UTF-8 and UTF-16 decoding iterators
 
 use fmt;
-use iter::FusedIterator;
 use super::from_u32_unchecked;
 
-/// An iterator over an iterator of bytes of the characters the bytes represent
-/// as UTF-8
-#[unstable(feature = "decode_utf8", issue = "33906")]
-#[rustc_deprecated(since = "1.27.0", reason = "Use str::from_utf8 instead:
- https://doc.rust-lang.org/nightly/std/str/struct.Utf8Error.html#examples")]
-#[derive(Clone, Debug)]
-#[allow(deprecated)]
-pub struct DecodeUtf8<I: Iterator<Item = u8>>(::iter::Peekable<I>);
-
-/// Decodes an `Iterator` of bytes as UTF-8.
-#[unstable(feature = "decode_utf8", issue = "33906")]
-#[rustc_deprecated(since = "1.27.0", reason = "Use str::from_utf8 instead:
- https://doc.rust-lang.org/nightly/std/str/struct.Utf8Error.html#examples")]
-#[allow(deprecated)]
-#[inline]
-pub fn decode_utf8<I: IntoIterator<Item = u8>>(i: I) -> DecodeUtf8<I::IntoIter> {
- DecodeUtf8(i.into_iter().peekable())
-}
-
-/// `<DecodeUtf8 as Iterator>::next` returns this for an invalid input sequence.
-#[unstable(feature = "decode_utf8", issue = "33906")]
-#[rustc_deprecated(since = "1.27.0", reason = "Use str::from_utf8 instead:
- https://doc.rust-lang.org/nightly/std/str/struct.Utf8Error.html#examples")]
-#[derive(PartialEq, Eq, Debug)]
-#[allow(deprecated)]
-pub struct InvalidSequence(());
-
-#[unstable(feature = "decode_utf8", issue = "33906")]
-#[allow(deprecated)]
-impl<I: Iterator<Item = u8>> Iterator for DecodeUtf8<I> {
- type Item = Result<char, InvalidSequence>;
- #[inline]
-
- fn next(&mut self) -> Option<Result<char, InvalidSequence>> {
- self.0.next().map(|first_byte| {
- // Emit InvalidSequence according to
- // Unicode §5.22 Best Practice for U+FFFD Substitution
- // http://www.unicode.org/versions/Unicode9.0.0/ch05.pdf#G40630
-
- // Roughly: consume at least one byte,
- // then validate one byte at a time and stop before the first unexpected byte
- // (which might be the valid start of the next byte sequence).
-
- let mut code_point;
- macro_rules! first_byte {
- ($mask: expr) => {
- code_point = u32::from(first_byte & $mask)
- }
- }
- macro_rules! continuation_byte {
- () => { continuation_byte!(0x80..=0xBF) };
- ($range: pat) => {
- match self.0.peek() {
- Some(&byte @ $range) => {
- code_point = (code_point << 6) | u32::from(byte & 0b0011_1111);
- self.0.next();
- }
- _ => return Err(InvalidSequence(()))
- }
- }
- }
-
- match first_byte {
- 0x00..=0x7F => {
- first_byte!(0b1111_1111);
- }
- 0xC2..=0xDF => {
- first_byte!(0b0001_1111);
- continuation_byte!();
- }
- 0xE0 => {
- first_byte!(0b0000_1111);
- continuation_byte!(0xA0..=0xBF); // 0x80..=0x9F here are overlong
- continuation_byte!();
- }
- 0xE1..=0xEC | 0xEE..=0xEF => {
- first_byte!(0b0000_1111);
- continuation_byte!();
- continuation_byte!();
- }
- 0xED => {
- first_byte!(0b0000_1111);
- continuation_byte!(0x80..=0x9F); // 0xA0..0xBF here are surrogates
- continuation_byte!();
- }
- 0xF0 => {
- first_byte!(0b0000_0111);
- continuation_byte!(0x90..=0xBF); // 0x80..0x8F here are overlong
- continuation_byte!();
- continuation_byte!();
- }
- 0xF1..=0xF3 => {
- first_byte!(0b0000_0111);
- continuation_byte!();
- continuation_byte!();
- continuation_byte!();
- }
- 0xF4 => {
- first_byte!(0b0000_0111);
- continuation_byte!(0x80..=0x8F); // 0x90..0xBF here are beyond char::MAX
- continuation_byte!();
- continuation_byte!();
- }
- _ => return Err(InvalidSequence(())) // Illegal first byte, overlong, or beyond MAX
- }
- unsafe {
- Ok(from_u32_unchecked(code_point))
- }
- })
- }
-
- #[inline]
- fn size_hint(&self) -> (usize, Option<usize>) {
- let (lower, upper) = self.0.size_hint();
-
- // A code point is at most 4 bytes long.
- let min_code_points = lower / 4;
-
- (min_code_points, upper)
- }
-}
-
-#[unstable(feature = "decode_utf8", issue = "33906")]
-#[allow(deprecated)]
-impl<I: FusedIterator<Item = u8>> FusedIterator for DecodeUtf8<I> {}
-
 /// An iterator that decodes UTF-16 encoded code points from an iterator of `u16`s.
 #[stable(feature = "decode_utf16", since = "1.9.0")]
 #[derive(Clone, Debug)]

src/libcore/char/mod.rs

@@ -50,11 +50,6 @@ pub use self::decode::{decode_utf16, DecodeUtf16, DecodeUtf16Error};
 pub use unicode::tables::UNICODE_VERSION;
 #[unstable(feature = "unicode_version", issue = "49726")]
 pub use unicode::version::UnicodeVersion;
-#[unstable(feature = "decode_utf8", issue = "33906")]
-#[rustc_deprecated(since = "1.27.0", reason = "Use str::from_utf8 instead:
- https://doc.rust-lang.org/nightly/std/str/struct.Utf8Error.html#examples")]
-#[allow(deprecated)]
-pub use self::decode::{decode_utf8, DecodeUtf8, InvalidSequence};
 
 use fmt::{self, Write};
 use iter::FusedIterator;

src/libcore/ptr.rs

@@ -680,46 +680,6 @@ impl<T: ?Sized> *const T {
  }
  }
 
- /// Calculates the distance between two pointers. The returned value is in
- /// units of T: the distance in bytes is divided by `mem::size_of::<T>()`.
- ///
- /// If the address different between the two pointers ia not a multiple of
- /// `mem::size_of::<T>()` then the result of the division is rounded towards
- /// zero.
- ///
- /// This function returns `None` if `T` is a zero-sized type.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// #![feature(offset_to)]
- /// #![allow(deprecated)]
- ///
- /// fn main() {
- /// let a = [0; 5];
- /// let ptr1: *const i32 = &a[1];
- /// let ptr2: *const i32 = &a[3];
- /// assert_eq!(ptr1.offset_to(ptr2), Some(2));
- /// assert_eq!(ptr2.offset_to(ptr1), Some(-2));
- /// assert_eq!(unsafe { ptr1.offset(2) }, ptr2);
- /// assert_eq!(unsafe { ptr2.offset(-2) }, ptr1);
- /// }
- /// ```
- #[unstable(feature = "offset_to", issue = "41079")]
- #[rustc_deprecated(since = "1.27.0", reason = "Replaced by `wrapping_offset_from`, with the \
- opposite argument order. If you're writing unsafe code, consider `offset_from`.")]
- #[inline]
- pub fn offset_to(self, other: *const T) -> Option<isize> where T: Sized {
- let size = mem::size_of::<T>();
- if size == 0 {
- None
- } else {
- Some(other.wrapping_offset_from(self))
- }
- }
-
  /// Calculates the distance between two pointers. The returned value is in
  /// units of T: the distance in bytes is divided by `mem::size_of::<T>()`.
  ///
@@ -1464,46 +1424,6 @@ impl<T: ?Sized> *mut T {
  }
  }
 
- /// Calculates the distance between two pointers. The returned value is in
- /// units of T: the distance in bytes is divided by `mem::size_of::<T>()`.
- ///
- /// If the address different between the two pointers ia not a multiple of
- /// `mem::size_of::<T>()` then the result of the division is rounded towards
- /// zero.
- ///
- /// This function returns `None` if `T` is a zero-sized type.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// #![feature(offset_to)]
- /// #![allow(deprecated)]
- ///
- /// fn main() {
- /// let mut a = [0; 5];
- /// let ptr1: *mut i32 = &mut a[1];
- /// let ptr2: *mut i32 = &mut a[3];
- /// assert_eq!(ptr1.offset_to(ptr2), Some(2));
- /// assert_eq!(ptr2.offset_to(ptr1), Some(-2));
- /// assert_eq!(unsafe { ptr1.offset(2) }, ptr2);
- /// assert_eq!(unsafe { ptr2.offset(-2) }, ptr1);
- /// }
- /// ```
- #[unstable(feature = "offset_to", issue = "41079")]
- #[rustc_deprecated(since = "1.27.0", reason = "Replaced by `wrapping_offset_from`, with the \
- opposite argument order. If you're writing unsafe code, consider `offset_from`.")]
- #[inline]
- pub fn offset_to(self, other: *const T) -> Option<isize> where T: Sized {
- let size = mem::size_of::<T>();
- if size == 0 {
- None
- } else {
- Some(other.wrapping_offset_from(self))
- }
- }
-
  /// Calculates the distance between two pointers. The returned value is in
  /// units of T: the distance in bytes is divided by `mem::size_of::<T>()`.
  ///

src/libcore/tests/char.rs

@@ -363,54 +363,3 @@ fn eu_iterator_specializations() {
  check('\u{12340}');
  check('\u{10FFFF}');
 }
-
-#[test]
-#[allow(deprecated)]
-fn test_decode_utf8() {
- macro_rules! assert_decode_utf8 {
- ($input_bytes: expr, $expected_str: expr) => {
- let input_bytes: &[u8] = &$input_bytes;
- let s = char::decode_utf8(input_bytes.iter().cloned())
- .map(|r_b| r_b.unwrap_or('\u{FFFD}'))
- .collect::<String>();
- assert_eq!(s, $expected_str,
- "input bytes: {:?}, expected str: {:?}, result: {:?}",
- input_bytes, $expected_str, s);
- assert_eq!(String::from_utf8_lossy(&$input_bytes), $expected_str);
- }
- }
-
- assert_decode_utf8!([], "");
- assert_decode_utf8!([0x41], "A");
- assert_decode_utf8!([0xC1, 0x81], "��");
- assert_decode_utf8!([0xE2, 0x99, 0xA5], "♥");
- assert_decode_utf8!([0xE2, 0x99, 0xA5, 0x41], "♥A");
- assert_decode_utf8!([0xE2, 0x99], "�");
- assert_decode_utf8!([0xE2, 0x99, 0x41], "�A");
- assert_decode_utf8!([0xC0], "�");
- assert_decode_utf8!([0xC0, 0x41], "�A");
- assert_decode_utf8!([0x80], "�");
- assert_decode_utf8!([0x80, 0x41], "�A");
- assert_decode_utf8!([0xFE], "�");
- assert_decode_utf8!([0xFE, 0x41], "�A");
- assert_decode_utf8!([0xFF], "�");
- assert_decode_utf8!([0xFF, 0x41], "�A");
- assert_decode_utf8!([0xC0, 0x80], "��");
-
- // Surrogates
- assert_decode_utf8!([0xED, 0x9F, 0xBF], "\u{D7FF}");
- assert_decode_utf8!([0xED, 0xA0, 0x80], "���");
- assert_decode_utf8!([0xED, 0xBF, 0x80], "���");
- assert_decode_utf8!([0xEE, 0x80, 0x80], "\u{E000}");
-
- // char::MAX
- assert_decode_utf8!([0xF4, 0x8F, 0xBF, 0xBF], "\u{10FFFF}");
- assert_decode_utf8!([0xF4, 0x8F, 0xBF, 0x41], "�A");
- assert_decode_utf8!([0xF4, 0x90, 0x80, 0x80], "����");
-
- // 5 and 6 bytes sequence
- // Part of the original design of UTF-8,
- // but invalid now that UTF-8 is artificially restricted to match the range of UTF-16.
- assert_decode_utf8!([0xF8, 0x80, 0x80, 0x80, 0x80], "�����");
- assert_decode_utf8!([0xFC, 0x80, 0x80, 0x80, 0x80, 0x80], "������");
-}

src/libstd/Cargo.toml

@@ -22,7 +22,6 @@ core = { path = "../libcore" }
 libc = { path = "../rustc/libc_shim" }
 compiler_builtins = { path = "../rustc/compiler_builtins_shim" }
 profiler_builtins = { path = "../libprofiler_builtins", optional = true }
-std_unicode = { path = "../libstd_unicode" }
 unwind = { path = "../libunwind" }
 
 [dev-dependencies]