Rollup merge of #52732 - SimonSapin:spring, r=Mark-Simulacrum
Remove unstable and deprecated APIs
This commit is contained in:
Pietro Albini
GitHub
commit
acff794b68
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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",
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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)]
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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>()`.
|
||||
///
|
||||
|
|
|
|||
|
|
@ -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], "<EFBFBD><EFBFBD>");
|
||||
assert_decode_utf8!([0xE2, 0x99, 0xA5], "♥");
|
||||
assert_decode_utf8!([0xE2, 0x99, 0xA5, 0x41], "♥A");
|
||||
assert_decode_utf8!([0xE2, 0x99], "<EFBFBD>");
|
||||
assert_decode_utf8!([0xE2, 0x99, 0x41], "<EFBFBD>A");
|
||||
assert_decode_utf8!([0xC0], "<EFBFBD>");
|
||||
assert_decode_utf8!([0xC0, 0x41], "<EFBFBD>A");
|
||||
assert_decode_utf8!([0x80], "<EFBFBD>");
|
||||
assert_decode_utf8!([0x80, 0x41], "<EFBFBD>A");
|
||||
assert_decode_utf8!([0xFE], "<EFBFBD>");
|
||||
assert_decode_utf8!([0xFE, 0x41], "<EFBFBD>A");
|
||||
assert_decode_utf8!([0xFF], "<EFBFBD>");
|
||||
assert_decode_utf8!([0xFF, 0x41], "<EFBFBD>A");
|
||||
assert_decode_utf8!([0xC0, 0x80], "<EFBFBD><EFBFBD>");
|
||||
|
||||
// Surrogates
|
||||
assert_decode_utf8!([0xED, 0x9F, 0xBF], "\u{D7FF}");
|
||||
assert_decode_utf8!([0xED, 0xA0, 0x80], "<EFBFBD><EFBFBD><EFBFBD>");
|
||||
assert_decode_utf8!([0xED, 0xBF, 0x80], "<EFBFBD><EFBFBD><EFBFBD>");
|
||||
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], "<EFBFBD>A");
|
||||
assert_decode_utf8!([0xF4, 0x90, 0x80, 0x80], "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
|
||||
|
||||
// 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], "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
|
||||
assert_decode_utf8!([0xFC, 0x80, 0x80, 0x80, 0x80, 0x80], "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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]
|
||||
|
|
|
|||
|
|
@ -154,180 +154,6 @@ pub trait AsciiExt {
|
|||
/// [`to_ascii_lowercase`]: #tymethod.to_ascii_lowercase
|
||||
#[stable(feature = "ascii", since = "1.9.0")]
|
||||
fn make_ascii_lowercase(&mut self);
|
||||
|
||||
/// Checks if the value is an ASCII alphabetic character:
|
||||
/// U+0041 'A' ... U+005A 'Z' or U+0061 'a' ... U+007A 'z'.
|
||||
/// For strings, true if all characters in the string are
|
||||
/// ASCII alphabetic.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This method will be deprecated in favor of the identically-named
|
||||
/// inherent methods on `u8` and `char`.
|
||||
/// For `[u8]` use `.iter().all(u8::is_ascii_alphabetic)`.
|
||||
/// For `str` use `.bytes().all(u8::is_ascii_alphabetic)`.
|
||||
#[unstable(feature = "ascii_ctype", issue = "39658")]
|
||||
#[rustc_deprecated(since = "1.26.0", reason = "use inherent methods instead")]
|
||||
fn is_ascii_alphabetic(&self) -> bool { unimplemented!(); }
|
||||
|
||||
/// Checks if the value is an ASCII uppercase character:
|
||||
/// U+0041 'A' ... U+005A 'Z'.
|
||||
/// For strings, true if all characters in the string are
|
||||
/// ASCII uppercase.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This method will be deprecated in favor of the identically-named
|
||||
/// inherent methods on `u8` and `char`.
|
||||
/// For `[u8]` use `.iter().all(u8::is_ascii_uppercase)`.
|
||||
/// For `str` use `.bytes().all(u8::is_ascii_uppercase)`.
|
||||
#[unstable(feature = "ascii_ctype", issue = "39658")]
|
||||
#[rustc_deprecated(since = "1.26.0", reason = "use inherent methods instead")]
|
||||
fn is_ascii_uppercase(&self) -> bool { unimplemented!(); }
|
||||
|
||||
/// Checks if the value is an ASCII lowercase character:
|
||||
/// U+0061 'a' ... U+007A 'z'.
|
||||
/// For strings, true if all characters in the string are
|
||||
/// ASCII lowercase.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This method will be deprecated in favor of the identically-named
|
||||
/// inherent methods on `u8` and `char`.
|
||||
/// For `[u8]` use `.iter().all(u8::is_ascii_lowercase)`.
|
||||
/// For `str` use `.bytes().all(u8::is_ascii_lowercase)`.
|
||||
#[unstable(feature = "ascii_ctype", issue = "39658")]
|
||||
#[rustc_deprecated(since = "1.26.0", reason = "use inherent methods instead")]
|
||||
fn is_ascii_lowercase(&self) -> bool { unimplemented!(); }
|
||||
|
||||
/// Checks if the value is an ASCII alphanumeric character:
|
||||
/// U+0041 'A' ... U+005A 'Z', U+0061 'a' ... U+007A 'z', or
|
||||
/// U+0030 '0' ... U+0039 '9'.
|
||||
/// For strings, true if all characters in the string are
|
||||
/// ASCII alphanumeric.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This method will be deprecated in favor of the identically-named
|
||||
/// inherent methods on `u8` and `char`.
|
||||
/// For `[u8]` use `.iter().all(u8::is_ascii_alphanumeric)`.
|
||||
/// For `str` use `.bytes().all(u8::is_ascii_alphanumeric)`.
|
||||
#[unstable(feature = "ascii_ctype", issue = "39658")]
|
||||
#[rustc_deprecated(since = "1.26.0", reason = "use inherent methods instead")]
|
||||
fn is_ascii_alphanumeric(&self) -> bool { unimplemented!(); }
|
||||
|
||||
/// Checks if the value is an ASCII decimal digit:
|
||||
/// U+0030 '0' ... U+0039 '9'.
|
||||
/// For strings, true if all characters in the string are
|
||||
/// ASCII digits.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This method will be deprecated in favor of the identically-named
|
||||
/// inherent methods on `u8` and `char`.
|
||||
/// For `[u8]` use `.iter().all(u8::is_ascii_digit)`.
|
||||
/// For `str` use `.bytes().all(u8::is_ascii_digit)`.
|
||||
#[unstable(feature = "ascii_ctype", issue = "39658")]
|
||||
#[rustc_deprecated(since = "1.26.0", reason = "use inherent methods instead")]
|
||||
fn is_ascii_digit(&self) -> bool { unimplemented!(); }
|
||||
|
||||
/// Checks if the value is an ASCII hexadecimal digit:
|
||||
/// U+0030 '0' ... U+0039 '9', U+0041 'A' ... U+0046 'F', or
|
||||
/// U+0061 'a' ... U+0066 'f'.
|
||||
/// For strings, true if all characters in the string are
|
||||
/// ASCII hex digits.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This method will be deprecated in favor of the identically-named
|
||||
/// inherent methods on `u8` and `char`.
|
||||
/// For `[u8]` use `.iter().all(u8::is_ascii_hexdigit)`.
|
||||
/// For `str` use `.bytes().all(u8::is_ascii_hexdigit)`.
|
||||
#[unstable(feature = "ascii_ctype", issue = "39658")]
|
||||
#[rustc_deprecated(since = "1.26.0", reason = "use inherent methods instead")]
|
||||
fn is_ascii_hexdigit(&self) -> bool { unimplemented!(); }
|
||||
|
||||
/// Checks if the value is an ASCII punctuation character:
|
||||
///
|
||||
/// U+0021 ... U+002F `! " # $ % & ' ( ) * + , - . /`
|
||||
/// U+003A ... U+0040 `: ; < = > ? @`
|
||||
/// U+005B ... U+0060 ``[ \\ ] ^ _ ` ``
|
||||
/// U+007B ... U+007E `{ | } ~`
|
||||
///
|
||||
/// For strings, true if all characters in the string are
|
||||
/// ASCII punctuation.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This method will be deprecated in favor of the identically-named
|
||||
/// inherent methods on `u8` and `char`.
|
||||
/// For `[u8]` use `.iter().all(u8::is_ascii_punctuation)`.
|
||||
/// For `str` use `.bytes().all(u8::is_ascii_punctuation)`.
|
||||
#[unstable(feature = "ascii_ctype", issue = "39658")]
|
||||
#[rustc_deprecated(since = "1.26.0", reason = "use inherent methods instead")]
|
||||
fn is_ascii_punctuation(&self) -> bool { unimplemented!(); }
|
||||
|
||||
/// Checks if the value is an ASCII graphic character:
|
||||
/// U+0021 '!' ... U+007E '~'.
|
||||
/// For strings, true if all characters in the string are
|
||||
/// ASCII graphic characters.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This method will be deprecated in favor of the identically-named
|
||||
/// inherent methods on `u8` and `char`.
|
||||
/// For `[u8]` use `.iter().all(u8::is_ascii_graphic)`.
|
||||
/// For `str` use `.bytes().all(u8::is_ascii_graphic)`.
|
||||
#[unstable(feature = "ascii_ctype", issue = "39658")]
|
||||
#[rustc_deprecated(since = "1.26.0", reason = "use inherent methods instead")]
|
||||
fn is_ascii_graphic(&self) -> bool { unimplemented!(); }
|
||||
|
||||
/// Checks if the value is an ASCII whitespace character:
|
||||
/// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,
|
||||
/// U+000C FORM FEED, or U+000D CARRIAGE RETURN.
|
||||
/// For strings, true if all characters in the string are
|
||||
/// ASCII whitespace.
|
||||
///
|
||||
/// Rust uses the WhatWG Infra Standard's [definition of ASCII
|
||||
/// whitespace][infra-aw]. There are several other definitions in
|
||||
/// wide use. For instance, [the POSIX locale][pct] includes
|
||||
/// U+000B VERTICAL TAB as well as all the above characters,
|
||||
/// but—from the very same specification—[the default rule for
|
||||
/// "field splitting" in the Bourne shell][bfs] considers *only*
|
||||
/// SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.
|
||||
///
|
||||
/// If you are writing a program that will process an existing
|
||||
/// file format, check what that format's definition of whitespace is
|
||||
/// before using this function.
|
||||
///
|
||||
/// [infra-aw]: https://infra.spec.whatwg.org/#ascii-whitespace
|
||||
/// [pct]: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01
|
||||
/// [bfs]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This method will be deprecated in favor of the identically-named
|
||||
/// inherent methods on `u8` and `char`.
|
||||
/// For `[u8]` use `.iter().all(u8::is_ascii_whitespace)`.
|
||||
/// For `str` use `.bytes().all(u8::is_ascii_whitespace)`.
|
||||
#[unstable(feature = "ascii_ctype", issue = "39658")]
|
||||
#[rustc_deprecated(since = "1.26.0", reason = "use inherent methods instead")]
|
||||
fn is_ascii_whitespace(&self) -> bool { unimplemented!(); }
|
||||
|
||||
/// Checks if the value is an ASCII control character:
|
||||
/// U+0000 NUL ... U+001F UNIT SEPARATOR, or U+007F DELETE.
|
||||
/// Note that most ASCII whitespace characters are control
|
||||
/// characters, but SPACE is not.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This method will be deprecated in favor of the identically-named
|
||||
/// inherent methods on `u8` and `char`.
|
||||
/// For `[u8]` use `.iter().all(u8::is_ascii_control)`.
|
||||
/// For `str` use `.bytes().all(u8::is_ascii_control)`.
|
||||
#[unstable(feature = "ascii_ctype", issue = "39658")]
|
||||
#[rustc_deprecated(since = "1.26.0", reason = "use inherent methods instead")]
|
||||
fn is_ascii_control(&self) -> bool { unimplemented!(); }
|
||||
}
|
||||
|
||||
macro_rules! delegating_ascii_methods {
|
||||
|
|
@ -352,47 +178,12 @@ macro_rules! delegating_ascii_methods {
|
|||
}
|
||||
}
|
||||
|
||||
macro_rules! delegating_ascii_ctype_methods {
|
||||
() => {
|
||||
#[inline]
|
||||
fn is_ascii_alphabetic(&self) -> bool { self.is_ascii_alphabetic() }
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_uppercase(&self) -> bool { self.is_ascii_uppercase() }
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_lowercase(&self) -> bool { self.is_ascii_lowercase() }
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_alphanumeric(&self) -> bool { self.is_ascii_alphanumeric() }
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_digit(&self) -> bool { self.is_ascii_digit() }
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_hexdigit(&self) -> bool { self.is_ascii_hexdigit() }
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_punctuation(&self) -> bool { self.is_ascii_punctuation() }
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_graphic(&self) -> bool { self.is_ascii_graphic() }
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_whitespace(&self) -> bool { self.is_ascii_whitespace() }
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_control(&self) -> bool { self.is_ascii_control() }
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow(deprecated)]
|
||||
impl AsciiExt for u8 {
|
||||
type Owned = u8;
|
||||
|
||||
delegating_ascii_methods!();
|
||||
delegating_ascii_ctype_methods!();
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
|
|
@ -401,7 +192,6 @@ impl AsciiExt for char {
|
|||
type Owned = char;
|
||||
|
||||
delegating_ascii_methods!();
|
||||
delegating_ascii_ctype_methods!();
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
|
|
@ -410,56 +200,6 @@ impl AsciiExt for [u8] {
|
|||
type Owned = Vec<u8>;
|
||||
|
||||
delegating_ascii_methods!();
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_alphabetic(&self) -> bool {
|
||||
self.iter().all(|b| b.is_ascii_alphabetic())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_uppercase(&self) -> bool {
|
||||
self.iter().all(|b| b.is_ascii_uppercase())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_lowercase(&self) -> bool {
|
||||
self.iter().all(|b| b.is_ascii_lowercase())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_alphanumeric(&self) -> bool {
|
||||
self.iter().all(|b| b.is_ascii_alphanumeric())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_digit(&self) -> bool {
|
||||
self.iter().all(|b| b.is_ascii_digit())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_hexdigit(&self) -> bool {
|
||||
self.iter().all(|b| b.is_ascii_hexdigit())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_punctuation(&self) -> bool {
|
||||
self.iter().all(|b| b.is_ascii_punctuation())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_graphic(&self) -> bool {
|
||||
self.iter().all(|b| b.is_ascii_graphic())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_whitespace(&self) -> bool {
|
||||
self.iter().all(|b| b.is_ascii_whitespace())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_control(&self) -> bool {
|
||||
self.iter().all(|b| b.is_ascii_control())
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
|
|
@ -468,54 +208,4 @@ impl AsciiExt for str {
|
|||
type Owned = String;
|
||||
|
||||
delegating_ascii_methods!();
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_alphabetic(&self) -> bool {
|
||||
self.bytes().all(|b| b.is_ascii_alphabetic())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_uppercase(&self) -> bool {
|
||||
self.bytes().all(|b| b.is_ascii_uppercase())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_lowercase(&self) -> bool {
|
||||
self.bytes().all(|b| b.is_ascii_lowercase())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_alphanumeric(&self) -> bool {
|
||||
self.bytes().all(|b| b.is_ascii_alphanumeric())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_digit(&self) -> bool {
|
||||
self.bytes().all(|b| b.is_ascii_digit())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_hexdigit(&self) -> bool {
|
||||
self.bytes().all(|b| b.is_ascii_hexdigit())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_punctuation(&self) -> bool {
|
||||
self.bytes().all(|b| b.is_ascii_punctuation())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_graphic(&self) -> bool {
|
||||
self.bytes().all(|b| b.is_ascii_graphic())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_whitespace(&self) -> bool {
|
||||
self.bytes().all(|b| b.is_ascii_whitespace())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_ascii_control(&self) -> bool {
|
||||
self.bytes().all(|b| b.is_ascii_control())
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -154,33 +154,6 @@ impl<R: Read> BufReader<R> {
|
|||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn get_mut(&mut self) -> &mut R { &mut self.inner }
|
||||
|
||||
/// Returns `true` if there are no bytes in the internal buffer.
|
||||
///
|
||||
/// # Examples
|
||||
//
|
||||
/// ```no_run
|
||||
/// # #![feature(bufreader_is_empty)]
|
||||
/// use std::io::BufReader;
|
||||
/// use std::io::BufRead;
|
||||
/// use std::fs::File;
|
||||
///
|
||||
/// fn main() -> std::io::Result<()> {
|
||||
/// let f1 = File::open("log.txt")?;
|
||||
/// let mut reader = BufReader::new(f1);
|
||||
/// assert!(reader.is_empty());
|
||||
///
|
||||
/// if reader.fill_buf()?.len() > 0 {
|
||||
/// assert!(!reader.is_empty());
|
||||
/// }
|
||||
/// Ok(())
|
||||
/// }
|
||||
/// ```
|
||||
#[unstable(feature = "bufreader_is_empty", issue = "45323", reason = "recently added")]
|
||||
#[rustc_deprecated(since = "1.26.0", reason = "use .buffer().is_empty() instead")]
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.buffer().is_empty()
|
||||
}
|
||||
|
||||
/// Returns a reference to the internally buffered data.
|
||||
///
|
||||
/// Unlike `fill_buf`, this will not attempt to fill the buffer if it is empty.
|
||||
|
|
@ -1265,25 +1238,6 @@ mod tests {
|
|||
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[allow(deprecated)]
|
||||
fn read_char_buffered() {
|
||||
let buf = [195, 159];
|
||||
let reader = BufReader::with_capacity(1, &buf[..]);
|
||||
assert_eq!(reader.chars().next().unwrap().unwrap(), 'ß');
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[allow(deprecated)]
|
||||
fn test_chars() {
|
||||
let buf = [195, 159, b'a'];
|
||||
let reader = BufReader::with_capacity(1, &buf[..]);
|
||||
let mut it = reader.chars();
|
||||
assert_eq!(it.next().unwrap().unwrap(), 'ß');
|
||||
assert_eq!(it.next().unwrap().unwrap(), 'a');
|
||||
assert!(it.next().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn dont_panic_in_drop_on_panicked_flush() {
|
||||
|
|
|
|||
|
|
@ -550,26 +550,6 @@ mod tests {
|
|||
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[allow(deprecated)]
|
||||
fn test_read_char() {
|
||||
let b = &b"Vi\xE1\xBB\x87t"[..];
|
||||
let mut c = Cursor::new(b).chars();
|
||||
assert_eq!(c.next().unwrap().unwrap(), 'V');
|
||||
assert_eq!(c.next().unwrap().unwrap(), 'i');
|
||||
assert_eq!(c.next().unwrap().unwrap(), 'ệ');
|
||||
assert_eq!(c.next().unwrap().unwrap(), 't');
|
||||
assert!(c.next().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[allow(deprecated)]
|
||||
fn test_read_bad_char() {
|
||||
let b = &b"\x80"[..];
|
||||
let mut c = Cursor::new(b).chars();
|
||||
assert!(c.next().unwrap().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn seek_past_end() {
|
||||
let buf = [0xff];
|
||||
|
|
|
|||
|
|
@ -270,10 +270,7 @@
|
|||
#![stable(feature = "rust1", since = "1.0.0")]
|
||||
|
||||
use cmp;
|
||||
use core::str as core_str;
|
||||
use error as std_error;
|
||||
use fmt;
|
||||
use result;
|
||||
use str;
|
||||
use memchr;
|
||||
use ptr;
|
||||
|
|
@ -800,53 +797,6 @@ pub trait Read {
|
|||
Bytes { inner: self }
|
||||
}
|
||||
|
||||
/// Transforms this `Read` instance to an [`Iterator`] over [`char`]s.
|
||||
///
|
||||
/// This adaptor will attempt to interpret this reader as a UTF-8 encoded
|
||||
/// sequence of characters. The returned iterator will return [`None`] once
|
||||
/// EOF is reached for this reader. Otherwise each element yielded will be a
|
||||
/// [`Result`]`<`[`char`]`, E>` where `E` may contain information about what I/O error
|
||||
/// occurred or where decoding failed.
|
||||
///
|
||||
/// Currently this adaptor will discard intermediate data read, and should
|
||||
/// be avoided if this is not desired.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// [`File`]s implement `Read`:
|
||||
///
|
||||
/// [`File`]: ../fs/struct.File.html
|
||||
/// [`Iterator`]: ../../std/iter/trait.Iterator.html
|
||||
/// [`Result`]: ../../std/result/enum.Result.html
|
||||
/// [`char`]: ../../std/primitive.char.html
|
||||
/// [`None`]: ../../std/option/enum.Option.html#variant.None
|
||||
///
|
||||
/// ```no_run
|
||||
/// #![feature(io)]
|
||||
/// use std::io;
|
||||
/// use std::io::prelude::*;
|
||||
/// use std::fs::File;
|
||||
///
|
||||
/// fn main() -> io::Result<()> {
|
||||
/// let mut f = File::open("foo.txt")?;
|
||||
///
|
||||
/// for c in f.chars() {
|
||||
/// println!("{}", c.unwrap());
|
||||
/// }
|
||||
/// Ok(())
|
||||
/// }
|
||||
/// ```
|
||||
#[unstable(feature = "io", reason = "the semantics of a partial read/write \
|
||||
of where errors happen is currently \
|
||||
unclear and may change",
|
||||
issue = "27802")]
|
||||
#[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)]
|
||||
fn chars(self) -> Chars<Self> where Self: Sized {
|
||||
Chars { inner: self }
|
||||
}
|
||||
|
||||
/// Creates an adaptor which will chain this stream with another.
|
||||
///
|
||||
/// The returned `Read` instance will first read all bytes from this object
|
||||
|
|
@ -2005,104 +1955,6 @@ impl<R: Read> Iterator for Bytes<R> {
|
|||
}
|
||||
}
|
||||
|
||||
/// An iterator over the `char`s of a reader.
|
||||
///
|
||||
/// This struct is generally created by calling [`chars`][chars] on a reader.
|
||||
/// Please see the documentation of `chars()` for more details.
|
||||
///
|
||||
/// [chars]: trait.Read.html#method.chars
|
||||
#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
|
||||
issue = "27802")]
|
||||
#[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(Debug)]
|
||||
#[allow(deprecated)]
|
||||
pub struct Chars<R> {
|
||||
inner: R,
|
||||
}
|
||||
|
||||
/// An enumeration of possible errors that can be generated from the `Chars`
|
||||
/// adapter.
|
||||
#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
|
||||
issue = "27802")]
|
||||
#[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(Debug)]
|
||||
#[allow(deprecated)]
|
||||
pub enum CharsError {
|
||||
/// Variant representing that the underlying stream was read successfully
|
||||
/// but it did not contain valid utf8 data.
|
||||
NotUtf8,
|
||||
|
||||
/// Variant representing that an I/O error occurred.
|
||||
Other(Error),
|
||||
}
|
||||
|
||||
#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
|
||||
issue = "27802")]
|
||||
#[allow(deprecated)]
|
||||
impl<R: Read> Iterator for Chars<R> {
|
||||
type Item = result::Result<char, CharsError>;
|
||||
|
||||
fn next(&mut self) -> Option<result::Result<char, CharsError>> {
|
||||
let first_byte = match read_one_byte(&mut self.inner)? {
|
||||
Ok(b) => b,
|
||||
Err(e) => return Some(Err(CharsError::Other(e))),
|
||||
};
|
||||
let width = core_str::utf8_char_width(first_byte);
|
||||
if width == 1 { return Some(Ok(first_byte as char)) }
|
||||
if width == 0 { return Some(Err(CharsError::NotUtf8)) }
|
||||
let mut buf = [first_byte, 0, 0, 0];
|
||||
{
|
||||
let mut start = 1;
|
||||
while start < width {
|
||||
match self.inner.read(&mut buf[start..width]) {
|
||||
Ok(0) => return Some(Err(CharsError::NotUtf8)),
|
||||
Ok(n) => start += n,
|
||||
Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
|
||||
Err(e) => return Some(Err(CharsError::Other(e))),
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(match str::from_utf8(&buf[..width]).ok() {
|
||||
Some(s) => Ok(s.chars().next().unwrap()),
|
||||
None => Err(CharsError::NotUtf8),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
|
||||
issue = "27802")]
|
||||
#[allow(deprecated)]
|
||||
impl std_error::Error for CharsError {
|
||||
fn description(&self) -> &str {
|
||||
match *self {
|
||||
CharsError::NotUtf8 => "invalid utf8 encoding",
|
||||
CharsError::Other(ref e) => std_error::Error::description(e),
|
||||
}
|
||||
}
|
||||
fn cause(&self) -> Option<&dyn std_error::Error> {
|
||||
match *self {
|
||||
CharsError::NotUtf8 => None,
|
||||
CharsError::Other(ref e) => e.cause(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
|
||||
issue = "27802")]
|
||||
#[allow(deprecated)]
|
||||
impl fmt::Display for CharsError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
match *self {
|
||||
CharsError::NotUtf8 => {
|
||||
"byte stream did not contain valid utf8".fmt(f)
|
||||
}
|
||||
CharsError::Other(ref e) => e.fmt(f),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator over the contents of an instance of `BufRead` split on a
|
||||
/// particular byte.
|
||||
///
|
||||
|
|
|
|||
|
|
@ -1,14 +0,0 @@
|
|||
[package]
|
||||
authors = ["The Rust Project Developers"]
|
||||
name = "std_unicode"
|
||||
version = "0.0.0"
|
||||
|
||||
[lib]
|
||||
name = "std_unicode"
|
||||
path = "lib.rs"
|
||||
test = false
|
||||
bench = false
|
||||
|
||||
[dependencies]
|
||||
core = { path = "../libcore" }
|
||||
compiler_builtins = { path = "../rustc/compiler_builtins_shim" }
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
//! # The Unicode Library
|
||||
//!
|
||||
//! Unicode-intensive functions for `char` and `str` types.
|
||||
//!
|
||||
//! This crate provides a collection of Unicode-related functionality,
|
||||
//! including decompositions, conversions, etc., and provides traits
|
||||
//! implementing these functions for the `char` and `str` types.
|
||||
//!
|
||||
//! The functionality included here is only that which is necessary to
|
||||
//! provide for basic string-related manipulations. This crate does not
|
||||
//! (yet) aim to provide a full set of Unicode tables.
|
||||
|
||||
#![unstable(feature = "unicode", issue = "27783")]
|
||||
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
|
||||
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
|
||||
html_root_url = "https://doc.rust-lang.org/nightly/",
|
||||
html_playground_url = "https://play.rust-lang.org/",
|
||||
issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
|
||||
test(no_crate_inject, attr(allow(unused_variables), deny(warnings))))]
|
||||
#![no_std]
|
||||
|
||||
#![feature(unicode_internals)]
|
||||
#![feature(staged_api)]
|
||||
#![rustc_deprecated(since = "1.27.0", reason = "moved into libcore")]
|
||||
|
||||
pub use core::unicode::*;
|
||||
Loading…
Reference in New Issue