mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #46362 - kennytm:rollup, r=kennytm

Browse Source 
Rollup of 10 pull requests

- Successful merges: #45969, #46077, #46219, #46287, #46293, #46322, #46323, #46330, #46354, #46356
- Failed merges:
This commit is contained in:
bors 2017-11-29 12:17:45 +00:00
commit 0a2e9ade83
53 changed files with 425 additions and 539 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
.travis.yml
View File

@ -16,12 +16,11 @@ matrix:
if: type = pull_request OR branch = auto
- env: IMAGE=dist-x86_64-linux DEPLOY=1
if: branch = auto
if: branch = try OR branch = auto
# "alternate" deployments, these are "nightlies" but don't have assertions
# turned on, they're deployed to a different location primarily for projects
# which are stuck on nightly and don't want llvm assertions in the artifacts
# that they use.
# "alternate" deployments, these are "nightlies" but have LLVM assertions
# turned on, they're deployed to a different location primarily for
# additional testing.
- env: IMAGE=dist-x86_64-linux DEPLOY_ALT=1
if: branch = try OR branch = auto
@ -312,20 +311,6 @@ deploy:
branch: auto
condition: $DEPLOY = 1
- provider: s3
bucket: rust-lang-ci2
skip_cleanup: true
local_dir: deploy
upload_dir: rustc-builds-try
acl: public_read
region: us-west-1
access_key_id: AKIAJVBODR3IA4O72THQ
secret_access_key:
secure: "kUGd3t7JcVWFESgIlzvsM8viZgCA9Encs3creW0xLJaLSeI1iVjlJK4h/2/nO6y224AFrh/GUfsNr4/4AlxPuYb8OU5oC5Lv+Ff2JiRDYtuNpyQSKAQp+bRYytWMtrmhja91h118Mbm90cUfcLPwkdiINgJNTXhPKg5Cqu3VYn0="
on:
branch: try
condition: $DEPLOY_ALT = 1
# this is the same as the above deployment provider except that it uploads to
# a slightly different directory and has a different trigger
- provider: s3
@ -341,3 +326,34 @@ deploy:
on:
branch: auto
condition: $DEPLOY_ALT = 1
# These two providers are the same as the two above, except deploy on the
# try branch. Travis does not appear to provide a way to use "or" in these
# conditions.
- provider: s3
bucket: rust-lang-ci2
skip_cleanup: true
local_dir: deploy
upload_dir: rustc-builds
acl: public_read
region: us-west-1
access_key_id: AKIAJVBODR3IA4O72THQ
secret_access_key:
secure: "kUGd3t7JcVWFESgIlzvsM8viZgCA9Encs3creW0xLJaLSeI1iVjlJK4h/2/nO6y224AFrh/GUfsNr4/4AlxPuYb8OU5oC5Lv+Ff2JiRDYtuNpyQSKAQp+bRYytWMtrmhja91h118Mbm90cUfcLPwkdiINgJNTXhPKg5Cqu3VYn0="
on:
branch: try
condition: $DEPLOY = 1
- provider: s3
bucket: rust-lang-ci2
skip_cleanup: true
local_dir: deploy
upload_dir: rustc-builds-alt
acl: public_read
region: us-west-1
access_key_id: AKIAJVBODR3IA4O72THQ
secret_access_key:
secure: "kUGd3t7JcVWFESgIlzvsM8viZgCA9Encs3creW0xLJaLSeI1iVjlJK4h/2/nO6y224AFrh/GUfsNr4/4AlxPuYb8OU5oC5Lv+Ff2JiRDYtuNpyQSKAQp+bRYytWMtrmhja91h118Mbm90cUfcLPwkdiINgJNTXhPKg5Cqu3VYn0="
on:
branch: try
condition: $DEPLOY_ALT = 1

237
src/liballoc/slice.rs
View File

@ -1428,15 +1428,45 @@ impl<T> [T] {
///
/// # Examples
///
/// ```
/// let mut dst = [0, 0, 0];
/// let src = [1, 2, 3];
/// Cloning two elements from a slice into another:
///
/// dst.clone_from_slice(&src);
/// assert!(dst == [1, 2, 3]);
/// ```
/// let src = [1, 2, 3, 4];
/// let mut dst = [0, 0];
///
/// dst.clone_from_slice(&src[2..]);
///
/// assert_eq!(src, [1, 2, 3, 4]);
/// assert_eq!(dst, [3, 4]);
/// ```
///
/// Rust enforces that there can only be one mutable reference with no
/// immutable references to a particular piece of data in a particular
/// scope. Because of this, attempting to use `clone_from_slice` on a
/// single slice will result in a compile failure:
///
/// ```compile_fail
/// let mut slice = [1, 2, 3, 4, 5];
///
/// slice[..2].clone_from_slice(&slice[3..]); // compile fail!
/// ```
///
/// To work around this, we can use [`split_at_mut`] to create two distinct
/// sub-slices from a slice:
///
/// ```
/// let mut slice = [1, 2, 3, 4, 5];
///
/// {
/// let (left, right) = slice.split_at_mut(2);
/// left.clone_from_slice(&right[1..]);
/// }
///
/// assert_eq!(slice, [4, 5, 3, 4, 5]);
/// ```
///
/// [`copy_from_slice`]: #method.copy_from_slice
/// [`split_at_mut`]: #method.split_at_mut
#[stable(feature = "clone_from_slice", since = "1.7.0")]
pub fn clone_from_slice(&mut self, src: &[T]) where T: Clone {
core_slice::SliceExt::clone_from_slice(self, src)
@ -1454,15 +1484,45 @@ impl<T> [T] {
///
/// # Examples
///
/// ```
/// let mut dst = [0, 0, 0];
/// let src = [1, 2, 3];
/// Copying two elements from a slice into another:
///
/// dst.copy_from_slice(&src);
/// assert_eq!(src, dst);
/// ```
/// let src = [1, 2, 3, 4];
/// let mut dst = [0, 0];
///
/// dst.copy_from_slice(&src[2..]);
///
/// assert_eq!(src, [1, 2, 3, 4]);
/// assert_eq!(dst, [3, 4]);
/// ```
///
/// Rust enforces that there can only be one mutable reference with no
/// immutable references to a particular piece of data in a particular
/// scope. Because of this, attempting to use `copy_from_slice` on a
/// single slice will result in a compile failure:
///
/// ```compile_fail
/// let mut slice = [1, 2, 3, 4, 5];
///
/// slice[..2].copy_from_slice(&slice[3..]); // compile fail!
/// ```
///
/// To work around this, we can use [`split_at_mut`] to create two distinct
/// sub-slices from a slice:
///
/// ```
/// let mut slice = [1, 2, 3, 4, 5];
///
/// {
/// let (left, right) = slice.split_at_mut(2);
/// left.copy_from_slice(&right[1..]);
/// }
///
/// assert_eq!(slice, [4, 5, 3, 4, 5]);
/// ```
///
/// [`clone_from_slice`]: #method.clone_from_slice
/// [`split_at_mut`]: #method.split_at_mut
#[stable(feature = "copy_from_slice", since = "1.9.0")]
pub fn copy_from_slice(&mut self, src: &[T]) where T: Copy {
core_slice::SliceExt::copy_from_slice(self, src)
@ -1478,16 +1538,49 @@ impl<T> [T] {
///
/// # Example
///
/// Swapping two elements across slices:
///
/// ```
/// #![feature(swap_with_slice)]
///
/// let mut slice1 = [1, 2, 3];
/// let mut slice2 = [7, 8, 9];
/// let mut slice1 = [0, 0];
/// let mut slice2 = [1, 2, 3, 4];
///
/// slice1.swap_with_slice(&mut slice2);
/// assert_eq!(slice1, [7, 8, 9]);
/// assert_eq!(slice2, [1, 2, 3]);
/// slice1.swap_with_slice(&mut slice2[2..]);
///
/// assert_eq!(slice1, [3, 4]);
/// assert_eq!(slice2, [1, 2, 0, 0]);
/// ```
///
/// Rust enforces that there can only be one mutable reference to a
/// particular piece of data in a particular scope. Because of this,
/// attempting to use `swap_with_slice` on a single slice will result in
/// a compile failure:
///
/// ```compile_fail
/// #![feature(swap_with_slice)]
///
/// let mut slice = [1, 2, 3, 4, 5];
/// slice[..2].swap_with_slice(&mut slice[3..]); // compile fail!
/// ```
///
/// To work around this, we can use [`split_at_mut`] to create two distinct
/// mutable sub-slices from a slice:
///
/// ```
/// #![feature(swap_with_slice)]
///
/// let mut slice = [1, 2, 3, 4, 5];
///
/// {
/// let (left, right) = slice.split_at_mut(2);
/// left.swap_with_slice(&mut right[1..]);
/// }
///
/// assert_eq!(slice, [4, 5, 3, 1, 2]);
/// ```
///
/// [`split_at_mut`]: #method.split_at_mut
#[unstable(feature = "swap_with_slice", issue = "44030")]
pub fn swap_with_slice(&mut self, other: &mut [T]) {
core_slice::SliceExt::swap_with_slice(self, other)
@ -1626,120 +1719,6 @@ impl [u8] {
byte.make_ascii_lowercase();
}
}
/// Checks if all bytes of this slice are ASCII alphabetic characters:
///
/// - U+0041 'A' ... U+005A 'Z', or
/// - U+0061 'a' ... U+007A 'z'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_alphabetic(&self) -> bool {
self.iter().all(|b| b.is_ascii_alphabetic())
}
/// Checks if all bytes of this slice are ASCII uppercase characters:
/// U+0041 'A' ... U+005A 'Z'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_uppercase(&self) -> bool {
self.iter().all(|b| b.is_ascii_uppercase())
}
/// Checks if all bytes of this slice are ASCII lowercase characters:
/// U+0061 'a' ... U+007A 'z'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_lowercase(&self) -> bool {
self.iter().all(|b| b.is_ascii_lowercase())
}
/// Checks if all bytes of this slice are ASCII alphanumeric characters:
///
/// - U+0041 'A' ... U+005A 'Z', or
/// - U+0061 'a' ... U+007A 'z', or
/// - U+0030 '0' ... U+0039 '9'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_alphanumeric(&self) -> bool {
self.iter().all(|b| b.is_ascii_alphanumeric())
}
/// Checks if all bytes of this slice are ASCII decimal digit:
/// U+0030 '0' ... U+0039 '9'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_digit(&self) -> bool {
self.iter().all(|b| b.is_ascii_digit())
}
/// Checks if all bytes of this slice are ASCII hexadecimal digits:
///
/// - U+0030 '0' ... U+0039 '9', or
/// - U+0041 'A' ... U+0046 'F', or
/// - U+0061 'a' ... U+0066 'f'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_hexdigit(&self) -> bool {
self.iter().all(|b| b.is_ascii_hexdigit())
}
/// Checks if all bytes of this slice are ASCII punctuation characters:
///
/// - U+0021 ... U+002F `! " # $ % & ' ( ) * + , - . /`, or
/// - U+003A ... U+0040 `: ; < = > ? @`, or
/// - U+005B ... U+0060 `[ \\ ] ^ _ \``, or
/// - U+007B ... U+007E `{ | } ~`
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_punctuation(&self) -> bool {
self.iter().all(|b| b.is_ascii_punctuation())
}
/// Checks if all bytes of this slice are ASCII graphic characters:
/// U+0021 '@' ... U+007E '~'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_graphic(&self) -> bool {
self.iter().all(|b| b.is_ascii_graphic())
}
/// Checks if all bytes of this slice are ASCII whitespace characters:
/// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,
/// U+000C FORM FEED, or U+000D CARRIAGE RETURN.
///
/// 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
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_whitespace(&self) -> bool {
self.iter().all(|b| b.is_ascii_whitespace())
}
/// Checks if all bytes of this slice are ASCII control characters:
///
/// - U+0000 NUL ... U+001F UNIT SEPARATOR, or
/// - U+007F DELETE.
///
/// Note that most ASCII whitespace characters are control
/// characters, but SPACE is not.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_control(&self) -> bool {
self.iter().all(|b| b.is_ascii_control())
}
}
////////////////////////////////////////////////////////////////////////////////

147
src/liballoc/str.rs
View File

@ -2199,153 +2199,6 @@ impl str {
let me = unsafe { self.as_bytes_mut() };
me.make_ascii_lowercase()
}
/// Checks if all characters of this string are ASCII alphabetic
/// characters:
///
/// - U+0041 'A' ... U+005A 'Z', or
/// - U+0061 'a' ... U+007A 'z'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_alphabetic(&self) -> bool {
self.bytes().all(|b| b.is_ascii_alphabetic())
}
/// Checks if all characters of this string are ASCII uppercase characters:
/// U+0041 'A' ... U+005A 'Z'.
///
/// # Example
///
/// ```
/// #![feature(ascii_ctype)]
///
/// // Only ascii uppercase characters
/// assert!("HELLO".is_ascii_uppercase());
///
/// // While all characters are ascii, 'y' and 'e' are not uppercase
/// assert!(!"Bye".is_ascii_uppercase());
///
/// // While all characters are uppercase, 'Ü' is not ascii
/// assert!(!"TSCHÜSS".is_ascii_uppercase());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_uppercase(&self) -> bool {
self.bytes().all(|b| b.is_ascii_uppercase())
}
/// Checks if all characters of this string are ASCII lowercase characters:
/// U+0061 'a' ... U+007A 'z'.
///
/// # Example
///
/// ```
/// #![feature(ascii_ctype)]
///
/// // Only ascii uppercase characters
/// assert!("hello".is_ascii_lowercase());
///
/// // While all characters are ascii, 'B' is not lowercase
/// assert!(!"Bye".is_ascii_lowercase());
///
/// // While all characters are lowercase, 'Ü' is not ascii
/// assert!(!"tschüss".is_ascii_lowercase());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_lowercase(&self) -> bool {
self.bytes().all(|b| b.is_ascii_lowercase())
}
/// Checks if all characters of this string are ASCII alphanumeric
/// characters:
///
/// - U+0041 'A' ... U+005A 'Z', or
/// - U+0061 'a' ... U+007A 'z', or
/// - U+0030 '0' ... U+0039 '9'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_alphanumeric(&self) -> bool {
self.bytes().all(|b| b.is_ascii_alphanumeric())
}
/// Checks if all characters of this string are ASCII decimal digit:
/// U+0030 '0' ... U+0039 '9'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_digit(&self) -> bool {
self.bytes().all(|b| b.is_ascii_digit())
}
/// Checks if all characters of this string are ASCII hexadecimal digits:
///
/// - U+0030 '0' ... U+0039 '9', or
/// - U+0041 'A' ... U+0046 'F', or
/// - U+0061 'a' ... U+0066 'f'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_hexdigit(&self) -> bool {
self.bytes().all(|b| b.is_ascii_hexdigit())
}
/// Checks if all characters of this string are ASCII punctuation
/// characters:
///
/// - U+0021 ... U+002F `! " # $ % & ' ( ) * + , - . /`, or
/// - U+003A ... U+0040 `: ; < = > ? @`, or
/// - U+005B ... U+0060 ``[ \ ] ^ _ ` ``, or
/// - U+007B ... U+007E `{ | } ~`
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_punctuation(&self) -> bool {
self.bytes().all(|b| b.is_ascii_punctuation())
}
/// Checks if all characters of this string are ASCII graphic characters:
/// U+0021 '@' ... U+007E '~'.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_graphic(&self) -> bool {
self.bytes().all(|b| b.is_ascii_graphic())
}
/// Checks if all characters of this string are ASCII whitespace characters:
/// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,
/// U+000C FORM FEED, or U+000D CARRIAGE RETURN.
///
/// 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
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_whitespace(&self) -> bool {
self.bytes().all(|b| b.is_ascii_whitespace())
}
/// Checks if all characters of this string are ASCII control characters:
///
/// - U+0000 NUL ... U+001F UNIT SEPARATOR, or
/// - U+007F DELETE.
///
/// Note that most ASCII whitespace characters are control
/// characters, but SPACE is not.
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[inline]
pub fn is_ascii_control(&self) -> bool {
self.bytes().all(|b| b.is_ascii_control())
}
}
/// Converts a boxed slice of bytes to a boxed string slice without checking

3
src/libcore/cell.rs
View File

@ -329,7 +329,6 @@ impl<T> Cell<T> {
/// let c = Cell::new(5);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_cell_new")]
#[inline]
pub const fn new(value: T) -> Cell<T> {
Cell {
@ -544,7 +543,6 @@ impl<T> RefCell<T> {
/// let c = RefCell::new(5);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_refcell_new")]
#[inline]
pub const fn new(value: T) -> RefCell<T> {
RefCell {
@ -1215,7 +1213,6 @@ impl<T> UnsafeCell<T> {
/// let uc = UnsafeCell::new(5);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_unsafe_cell_new")]
#[inline]
pub const fn new(value: T) -> UnsafeCell<T> {
UnsafeCell { value: value }

2
src/libcore/fmt/num.rs
View File

@ -134,7 +134,7 @@ macro_rules! radix {
}
}
radix! { Binary, 2, "0b", x @ 0 ... 2 => b'0' + x }
radix! { Binary, 2, "0b", x @ 0 ... 1 => b'0' + x }
radix! { Octal, 8, "0o", x @ 0 ... 7 => b'0' + x }
radix! { Decimal, 10, "", x @ 0 ... 9 => b'0' + x }
radix! { LowerHex, 16, "0x", x @ 0 ... 9 => b'0' + x,

34
src/libcore/lib.rs
View File

@ -85,47 +85,13 @@
#![feature(prelude_import)]
#![feature(repr_simd, platform_intrinsics)]
#![feature(rustc_attrs)]
#![feature(rustc_const_unstable)]
#![feature(specialization)]
#![feature(staged_api)]
#![feature(unboxed_closures)]
#![feature(untagged_unions)]
#![feature(unwind_attributes)]
#![feature(const_min_value)]
#![feature(const_max_value)]
#![feature(const_atomic_bool_new)]
#![feature(const_atomic_isize_new)]
#![feature(const_atomic_usize_new)]
#![feature(const_atomic_i8_new)]
#![feature(const_atomic_u8_new)]
#![feature(const_atomic_i16_new)]
#![feature(const_atomic_u16_new)]
#![feature(const_atomic_i32_new)]
#![feature(const_atomic_u32_new)]
#![feature(const_atomic_i64_new)]
#![feature(const_atomic_u64_new)]
#![feature(const_unsafe_cell_new)]
#![feature(const_cell_new)]
#![feature(const_nonzero_new)]
#![cfg_attr(not(stage0), feature(doc_spotlight))]
#![cfg_attr(not(stage0), feature(const_min_value))]
#![cfg_attr(not(stage0), feature(const_max_value))]
#![cfg_attr(not(stage0), feature(const_atomic_bool_new))]
#![cfg_attr(not(stage0), feature(const_atomic_isize_new))]
#![cfg_attr(not(stage0), feature(const_atomic_usize_new))]
#![cfg_attr(not(stage0), feature(const_atomic_i8_new))]
#![cfg_attr(not(stage0), feature(const_atomic_u8_new))]
#![cfg_attr(not(stage0), feature(const_atomic_i16_new))]
#![cfg_attr(not(stage0), feature(const_atomic_u16_new))]
#![cfg_attr(not(stage0), feature(const_atomic_i32_new))]
#![cfg_attr(not(stage0), feature(const_atomic_u32_new))]
#![cfg_attr(not(stage0), feature(const_atomic_i64_new))]
#![cfg_attr(not(stage0), feature(const_atomic_u64_new))]
#![cfg_attr(not(stage0), feature(const_unsafe_cell_new))]
#![cfg_attr(not(stage0), feature(const_cell_new))]
#![cfg_attr(not(stage0), feature(const_nonzero_new))]
#[prelude_import]
#[allow(unused)]
use prelude::v1::*;

2
src/libcore/mem.rs
View File

@ -311,7 +311,6 @@ pub fn forget<T>(t: T) {
/// [alignment]: ./fn.align_of.html
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_size_of")]
pub const fn size_of<T>() -> usize {
unsafe { intrinsics::size_of::<T>() }
}
@ -403,7 +402,6 @@ pub fn min_align_of_val<T: ?Sized>(val: &T) -> usize {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_align_of")]
pub const fn align_of<T>() -> usize {
unsafe { intrinsics::min_align_of::<T>() }
}

1
src/libcore/nonzero.rs
View File

@ -70,7 +70,6 @@ impl<T: Zeroable> NonZero<T> {
#[unstable(feature = "nonzero",
reason = "needs an RFC to flesh out the design",
issue = "27730")]
#[rustc_const_unstable(feature = "const_nonzero_new")]
#[inline]
pub const unsafe fn new_unchecked(inner: T) -> Self {
NonZero(inner)

24
src/libcore/num/mod.rs
View File

@ -110,7 +110,6 @@ macro_rules! int_impl {
/// assert_eq!(i8::min_value(), -128);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_min_value")]
#[inline]
pub const fn min_value() -> Self {
!0 ^ ((!0 as $UnsignedT) >> 1) as Self
@ -124,7 +123,6 @@ macro_rules! int_impl {
/// assert_eq!(i8::max_value(), 127);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_max_value")]
#[inline]
pub const fn max_value() -> Self {
!Self::min_value()
@ -1290,7 +1288,6 @@ macro_rules! uint_impl {
/// assert_eq!(u8::min_value(), 0);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_min_value")]
#[inline]
pub const fn min_value() -> Self { 0 }
@ -1302,7 +1299,6 @@ macro_rules! uint_impl {
/// assert_eq!(u8::max_value(), 255);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_max_value")]
#[inline]
pub const fn max_value() -> Self { !0 }
@ -2438,7 +2434,7 @@ impl u8 {
/// assert!(!lf.is_ascii_alphabetic());
/// assert!(!esc.is_ascii_alphabetic());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_alphabetic(&self) -> bool {
if *self >= 0x80 { return false; }
@ -2476,7 +2472,7 @@ impl u8 {
/// assert!(!lf.is_ascii_uppercase());
/// assert!(!esc.is_ascii_uppercase());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_uppercase(&self) -> bool {
if *self >= 0x80 { return false }
@ -2514,7 +2510,7 @@ impl u8 {
/// assert!(!lf.is_ascii_lowercase());
/// assert!(!esc.is_ascii_lowercase());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_lowercase(&self) -> bool {
if *self >= 0x80 { return false }
@ -2555,7 +2551,7 @@ impl u8 {
/// assert!(!lf.is_ascii_alphanumeric());
/// assert!(!esc.is_ascii_alphanumeric());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_alphanumeric(&self) -> bool {
if *self >= 0x80 { return false }
@ -2593,7 +2589,7 @@ impl u8 {
/// assert!(!lf.is_ascii_digit());
/// assert!(!esc.is_ascii_digit());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_digit(&self) -> bool {
if *self >= 0x80 { return false }
@ -2634,7 +2630,7 @@ impl u8 {
/// assert!(!lf.is_ascii_hexdigit());
/// assert!(!esc.is_ascii_hexdigit());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_hexdigit(&self) -> bool {
if *self >= 0x80 { return false }
@ -2676,7 +2672,7 @@ impl u8 {
/// assert!(!lf.is_ascii_punctuation());
/// assert!(!esc.is_ascii_punctuation());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_punctuation(&self) -> bool {
if *self >= 0x80 { return false }
@ -2714,7 +2710,7 @@ impl u8 {
/// assert!(!lf.is_ascii_graphic());
/// assert!(!esc.is_ascii_graphic());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_graphic(&self) -> bool {
if *self >= 0x80 { return false; }
@ -2769,7 +2765,7 @@ impl u8 {
/// assert!(lf.is_ascii_whitespace());
/// assert!(!esc.is_ascii_whitespace());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_whitespace(&self) -> bool {
if *self >= 0x80 { return false; }
@ -2809,7 +2805,7 @@ impl u8 {
/// assert!(lf.is_ascii_control());
/// assert!(esc.is_ascii_control());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_control(&self) -> bool {
if *self >= 0x80 { return false; }

4
src/libcore/ptr.rs
View File

@ -74,7 +74,6 @@ pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_ptr_null")]
pub const fn null<T>() -> *const T { 0 as *const T }
/// Creates a null mutable raw pointer.
@ -89,7 +88,6 @@ pub const fn null<T>() -> *const T { 0 as *const T }
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_ptr_null_mut")]
pub const fn null_mut<T>() -> *mut T { 0 as *mut T }
/// Swaps the values at two mutable locations of the same type, without
@ -2347,7 +2345,6 @@ impl<T: ?Sized> Unique<T> {
///
/// `ptr` must be non-null.
#[unstable(feature = "unique", issue = "27730")]
#[rustc_const_unstable(feature = "const_unique_new")]
pub const unsafe fn new_unchecked(ptr: *mut T) -> Self {
Unique { pointer: NonZero::new_unchecked(ptr), _marker: PhantomData }
}
@ -2482,7 +2479,6 @@ impl<T: ?Sized> Shared<T> {
///
/// `ptr` must be non-null.
#[unstable(feature = "shared", issue = "27730")]
#[rustc_const_unstable(feature = "const_shared_new")]
pub const unsafe fn new_unchecked(ptr: *mut T) -> Self {
Shared { pointer: NonZero::new_unchecked(ptr), _marker: PhantomData }
}

22
src/libcore/sync/atomic.rs
View File

@ -242,7 +242,6 @@ impl AtomicBool {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_atomic_bool_new")]
pub const fn new(v: bool) -> AtomicBool {
AtomicBool { v: UnsafeCell::new(v as u8) }
}
@ -656,7 +655,6 @@ impl<T> AtomicPtr<T> {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_atomic_ptr_new")]
pub const fn new(p: *mut T) -> AtomicPtr<T> {
AtomicPtr { p: UnsafeCell::new(p) }
}
@ -926,6 +924,13 @@ impl<T> AtomicPtr<T> {
}
}
#[cfg(target_has_atomic = "8")]
#[stable(feature = "atomic_bool_from", since = "1.24.0")]
impl From<bool> for AtomicBool {
#[inline]
fn from(b: bool) -> Self { Self::new(b) }
}
#[cfg(target_has_atomic = "ptr")]
#[stable(feature = "atomic_from", since = "1.23.0")]
impl<T> From<*mut T> for AtomicPtr<T> {
@ -935,7 +940,7 @@ impl<T> From<*mut T> for AtomicPtr<T> {
#[cfg(target_has_atomic = "ptr")]
macro_rules! atomic_int {
($stable:meta, $const_unstable:meta,
($stable:meta,
$stable_cxchg:meta,
$stable_debug:meta,
$stable_access:meta,
@ -1004,7 +1009,6 @@ macro_rules! atomic_int {
/// ```
#[inline]
#[$stable]
#[$const_unstable]
pub const fn new(v: $int_type) -> Self {
$atomic_type {v: UnsafeCell::new(v)}
}
@ -1368,7 +1372,6 @@ macro_rules! atomic_int {
#[cfg(target_has_atomic = "8")]
atomic_int! {
unstable(feature = "integer_atomics", issue = "32976"),
rustc_const_unstable(feature = "const_atomic_i8_new"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
@ -1378,7 +1381,6 @@ atomic_int! {
#[cfg(target_has_atomic = "8")]
atomic_int! {
unstable(feature = "integer_atomics", issue = "32976"),
rustc_const_unstable(feature = "const_atomic_u8_new"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
@ -1388,7 +1390,6 @@ atomic_int! {
#[cfg(target_has_atomic = "16")]
atomic_int! {
unstable(feature = "integer_atomics", issue = "32976"),
rustc_const_unstable(feature = "const_atomic_i16_new"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
@ -1398,7 +1399,6 @@ atomic_int! {
#[cfg(target_has_atomic = "16")]
atomic_int! {
unstable(feature = "integer_atomics", issue = "32976"),
rustc_const_unstable(feature = "const_atomic_u16_new"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
@ -1408,7 +1408,6 @@ atomic_int! {
#[cfg(target_has_atomic = "32")]
atomic_int! {
unstable(feature = "integer_atomics", issue = "32976"),
rustc_const_unstable(feature = "const_atomic_i32_new"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
@ -1418,7 +1417,6 @@ atomic_int! {
#[cfg(target_has_atomic = "32")]
atomic_int! {
unstable(feature = "integer_atomics", issue = "32976"),
rustc_const_unstable(feature = "const_atomic_u32_new"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
@ -1428,7 +1426,6 @@ atomic_int! {
#[cfg(target_has_atomic = "64")]
atomic_int! {
unstable(feature = "integer_atomics", issue = "32976"),
rustc_const_unstable(feature = "const_atomic_i64_new"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
@ -1438,7 +1435,6 @@ atomic_int! {
#[cfg(target_has_atomic = "64")]
atomic_int! {
unstable(feature = "integer_atomics", issue = "32976"),
rustc_const_unstable(feature = "const_atomic_u64_new"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
@ -1448,7 +1444,6 @@ atomic_int! {
#[cfg(target_has_atomic = "ptr")]
atomic_int!{
stable(feature = "rust1", since = "1.0.0"),
rustc_const_unstable(feature = "const_atomic_isize_new"),
stable(feature = "extended_compare_and_swap", since = "1.10.0"),
stable(feature = "atomic_debug", since = "1.3.0"),
stable(feature = "atomic_access", since = "1.15.0"),
@ -1458,7 +1453,6 @@ atomic_int!{
#[cfg(target_has_atomic = "ptr")]
atomic_int!{
stable(feature = "rust1", since = "1.0.0"),
rustc_const_unstable(feature = "const_atomic_usize_new"),
stable(feature = "extended_compare_and_swap", since = "1.10.0"),
stable(feature = "atomic_debug", since = "1.3.0"),
stable(feature = "atomic_access", since = "1.15.0"),

4
src/libcore/tests/lib.rs
View File

@ -42,10 +42,6 @@
#![feature(try_trait)]
#![feature(unique)]
#![feature(const_atomic_bool_new)]
#![feature(const_atomic_usize_new)]
#![feature(const_atomic_isize_new)]
extern crate core;
extern crate test;

1
src/librustc/lib.rs
View File

@ -64,7 +64,6 @@
#![feature(underscore_lifetimes)]
#![feature(trace_macros)]
#![feature(test)]
#![feature(const_atomic_bool_new)]
#![recursion_limit="512"]

2
src/librustc_apfloat/lib.rs
View File

@ -45,8 +45,6 @@
#![deny(warnings)]
#![forbid(unsafe_code)]
#![feature(const_max_value)]
#![feature(const_min_value)]
#![feature(i128_type)]
#![feature(slice_patterns)]
#![feature(try_from)]

2
src/librustc_const_eval/lib.rs
View File

@ -25,8 +25,6 @@
#![feature(box_syntax)]
#![feature(i128_type)]
#![feature(const_min_value)]
extern crate arena;
#[macro_use] extern crate syntax;
#[macro_use] extern crate log;

3
src/librustc_const_math/lib.rs
View File

@ -22,9 +22,6 @@
#![feature(i128)]
#![feature(i128_type)]
#![feature(const_min_value)]
#![feature(const_max_value)]
extern crate rustc_apfloat;
extern crate syntax;

4
src/librustc_mir/diagnostics.rs
View File

@ -770,8 +770,6 @@ static B: &'static AtomicUsize = &A; // ok!
You can also have this error while using a cell type:
```compile_fail,E0492
#![feature(const_cell_new)]
use std::cell::Cell;
const A: Cell<usize> = Cell::new(1);
@ -798,8 +796,6 @@ However, if you still wish to use these types, you can achieve this by an unsafe
wrapper:
```
#![feature(const_cell_new)]
use std::cell::Cell;
use std::marker::Sync;

3
src/librustc_trans/lib.rs
View File

@ -33,9 +33,6 @@
#![feature(slice_patterns)]
#![feature(conservative_impl_trait)]
#![feature(const_atomic_bool_new)]
#![feature(const_once_new)]
use rustc::dep_graph::WorkProduct;
use syntax_pos::symbol::Symbol;

5
src/librustc_trans/llvm_util.rs
View File

@ -85,7 +85,7 @@ const X86_WHITELIST: &'static [&'static str] = &["avx\0", "avx2\0", "bmi\0", "bm
"avx512dq\0", "avx512er\0",
"avx512f\0", "avx512ifma\0",
"avx512pf\0", "avx512vbmi\0",
"avx512vl\0", "avx512vpopcntdq\0"];
"avx512vl\0", "avx512vpopcntdq\0", "mmx\0"];
const HEXAGON_WHITELIST: &'static [&'static str] = &["hvx\0", "hvx-double\0"];
@ -94,6 +94,8 @@ const POWERPC_WHITELIST: &'static [&'static str] = &["altivec\0",
"power8-vector\0", "power9-vector\0",
"vsx\0"];
const MIPS_WHITELIST: &'static [&'static str] = &["msa\0"];
pub fn target_features(sess: &Session) -> Vec<Symbol> {
let target_machine = create_target_machine(sess);
@ -102,6 +104,7 @@ pub fn target_features(sess: &Session) -> Vec<Symbol> {
"aarch64" => AARCH64_WHITELIST,
"x86" | "x86_64" => X86_WHITELIST,
"hexagon" => HEXAGON_WHITELIST,
"mips" | "mips64" => MIPS_WHITELIST,
"powerpc" | "powerpc64" => POWERPC_WHITELIST,
_ => &[],
};

229
src/libstd/ascii.rs
View File

@ -490,77 +490,199 @@ impl AsciiExt for [u8] {
}
}
macro_rules! impl_by_delegating {
($ty:ty, $owned:ty) => {
#[stable(feature = "rust1", since = "1.0.0")]
impl AsciiExt for $ty {
type Owned = $owned;
macro_rules! delegating_ascii_methods {
() => {
#[inline]
fn is_ascii(&self) -> bool { self.is_ascii() }
#[inline]
fn is_ascii(&self) -> bool { self.is_ascii() }
#[inline]
fn to_ascii_uppercase(&self) -> Self::Owned { self.to_ascii_uppercase() }
#[inline]
fn to_ascii_uppercase(&self) -> Self::Owned { self.to_ascii_uppercase() }
#[inline]
fn to_ascii_lowercase(&self) -> Self::Owned { self.to_ascii_lowercase() }
#[inline]
fn to_ascii_lowercase(&self) -> Self::Owned { self.to_ascii_lowercase() }
#[inline]
fn eq_ignore_ascii_case(&self, o: &Self) -> bool { self.eq_ignore_ascii_case(o) }
#[inline]
fn eq_ignore_ascii_case(&self, o: &Self) -> bool { self.eq_ignore_ascii_case(o) }
#[inline]
fn make_ascii_uppercase(&mut self) { self.make_ascii_uppercase(); }
#[inline]
fn make_ascii_uppercase(&mut self) { self.make_ascii_uppercase(); }
#[inline]
fn make_ascii_lowercase(&mut self) { self.make_ascii_lowercase(); }
#[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() }
}
#[inline]
fn make_ascii_lowercase(&mut self) { self.make_ascii_lowercase(); }
}
}
impl_by_delegating!(u8, u8);
impl_by_delegating!(char, char);
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")]
impl AsciiExt for u8 {
type Owned = u8;
delegating_ascii_methods!();
delegating_ascii_ctype_methods!();
}
#[stable(feature = "rust1", since = "1.0.0")]
impl AsciiExt for char {
type Owned = char;
delegating_ascii_methods!();
delegating_ascii_ctype_methods!();
}
// FIXME(LukasKalbertodt): the macro invocation should replace the impl block
// for `[u8]` above. But this is not possible until the stage0 compiler is new
// enough to contain the inherent ascii methods for `[u8]`.
#[cfg(not(stage0))]
impl_by_delegating!([u8], Vec<u8>);
#[stable(feature = "rust1", since = "1.0.0")]
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())
}
}
// FIXME(LukasKalbertodt): the macro invocation should replace the impl block
// for `str` above. But this is not possible until the stage0 compiler is new
// enough to contain the inherent ascii methods for `str`.
#[cfg(not(stage0))]
impl_by_delegating!(str, String);
#[stable(feature = "rust1", since = "1.0.0")]
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())
}
}
/// An iterator over the escaped version of a byte.
///
@ -684,6 +806,7 @@ mod tests {
//! Note that most of these tests are not testing `AsciiExt` methods, but
//! test inherent ascii methods of char, u8, str and [u8]. `AsciiExt` is
//! just using those methods, though.
use super::AsciiExt;
use char::from_u32;
#[test]

11
src/libstd/lib.rs
View File

@ -256,15 +256,6 @@
#![feature(collections_range)]
#![feature(compiler_builtins_lib)]
#![feature(const_fn)]
#![feature(const_max_value)]
#![feature(const_atomic_bool_new)]
#![feature(const_atomic_isize_new)]
#![feature(const_atomic_usize_new)]
#![feature(const_unsafe_cell_new)]
#![feature(const_cell_new)]
#![feature(const_once_new)]
#![feature(const_ptr_null)]
#![feature(const_ptr_null_mut)]
#![feature(core_float)]
#![feature(core_intrinsics)]
#![feature(dropck_eyepatch)]
@ -306,7 +297,6 @@
#![feature(repr_align)]
#![feature(repr_simd)]
#![feature(rustc_attrs)]
#![feature(rustc_const_unstable)]
#![feature(shared)]
#![feature(sip_hash_13)]
#![feature(slice_bytes)]
@ -331,7 +321,6 @@
#![feature(doc_masked)]
#![feature(doc_spotlight)]
#![cfg_attr(test, feature(update_panic_count))]
#![cfg_attr(windows, feature(const_atomic_ptr_new))]
#![cfg_attr(windows, feature(used))]
#![default_lib_allocator]

71
src/libstd/sync/mpsc/mod.rs
View File

@ -1297,11 +1297,72 @@ impl<T> Receiver<T> {
Err(TryRecvError::Disconnected)
=> Err(RecvTimeoutError::Disconnected),
Err(TryRecvError::Empty)
=> self.recv_max_until(Instant::now() + timeout)
=> self.recv_deadline(Instant::now() + timeout)
}
}
fn recv_max_until(&self, deadline: Instant) -> Result<T, RecvTimeoutError> {
/// Attempts to wait for a value on this receiver, returning an error if the
/// corresponding channel has hung up, or if `deadline` is reached.
///
/// This function will always block the current thread if there is no data
/// available and it's possible for more data to be sent. Once a message is
/// sent to the corresponding [`Sender`][] (or [`SyncSender`]), then this
/// receiver will wake up and return that message.
///
/// If the corresponding [`Sender`] has disconnected, or it disconnects while
/// this call is blocking, this call will wake up and return [`Err`] to
/// indicate that no more messages can ever be received on this channel.
/// However, since channels are buffered, messages sent before the disconnect
/// will still be properly received.
///
/// [`Sender`]: struct.Sender.html
/// [`SyncSender`]: struct.SyncSender.html
/// [`Err`]: ../../../std/result/enum.Result.html#variant.Err
///
/// # Examples
///
/// Successfully receiving value before reaching deadline:
///
/// ```no_run
/// #![feature(deadline_api)]
/// use std::thread;
/// use std::time::{Duration, Instant};
/// use std::sync::mpsc;
///
/// let (send, recv) = mpsc::channel();
///
/// thread::spawn(move || {
/// send.send('a').unwrap();
/// });
///
/// assert_eq!(
/// recv.recv_deadline(Instant::now() + Duration::from_millis(400)),
/// Ok('a')
/// );
/// ```
///
/// Receiving an error upon reaching deadline:
///
/// ```no_run
/// #![feature(deadline_api)]
/// use std::thread;
/// use std::time::{Duration, Instant};
/// use std::sync::mpsc;
///
/// let (send, recv) = mpsc::channel();
///
/// thread::spawn(move || {
/// thread::sleep(Duration::from_millis(800));
/// send.send('a').unwrap();
/// });
///
/// assert_eq!(
/// recv.recv_deadline(Instant::now() + Duration::from_millis(400)),
/// Err(mpsc::RecvTimeoutError::Timeout)
/// );
/// ```
#[unstable(feature = "deadline_api", issue = "46316")]
pub fn recv_deadline(&self, deadline: Instant) -> Result<T, RecvTimeoutError> {
use self::RecvTimeoutError::*;
loop {
@ -1625,7 +1686,7 @@ impl<T: Send> error::Error for TrySendError<T> {
}
}
#[stable(feature = "mpsc_error_conversions", since = "1.23.0")]
#[stable(feature = "mpsc_error_conversions", since = "1.24.0")]
impl<T> From<SendError<T>> for TrySendError<T> {
fn from(err: SendError<T>) -> TrySendError<T> {
match err {
@ -1686,7 +1747,7 @@ impl error::Error for TryRecvError {
}
}
#[stable(feature = "mpsc_error_conversions", since = "1.23.0")]
#[stable(feature = "mpsc_error_conversions", since = "1.24.0")]
impl From<RecvError> for TryRecvError {
fn from(err: RecvError) -> TryRecvError {
match err {
@ -1727,7 +1788,7 @@ impl error::Error for RecvTimeoutError {
}
}
#[stable(feature = "mpsc_error_conversions", since = "1.23.0")]
#[stable(feature = "mpsc_error_conversions", since = "1.24.0")]
impl From<RecvError> for RecvTimeoutError {
fn from(err: RecvError) -> RecvTimeoutError {
match err {

1
src/libstd/sync/once.rs
View File

@ -156,7 +156,6 @@ struct Finish {
impl Once {
/// Creates a new `Once` value.
#[stable(feature = "once_new", since = "1.2.0")]
#[rustc_const_unstable(feature = "const_once_new")]
pub const fn new() -> Once {
Once {
state: AtomicUsize::new(INCOMPLETE),

20
src/libstd_unicode/char.rs
View File

@ -1109,7 +1109,7 @@ impl char {
/// assert!(!lf.is_ascii_alphabetic());
/// assert!(!esc.is_ascii_alphabetic());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_alphabetic(&self) -> bool {
self.is_ascii() && (*self as u8).is_ascii_alphabetic()
@ -1143,7 +1143,7 @@ impl char {
/// assert!(!lf.is_ascii_uppercase());
/// assert!(!esc.is_ascii_uppercase());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_uppercase(&self) -> bool {
self.is_ascii() && (*self as u8).is_ascii_uppercase()
@ -1177,7 +1177,7 @@ impl char {
/// assert!(!lf.is_ascii_lowercase());
/// assert!(!esc.is_ascii_lowercase());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_lowercase(&self) -> bool {
self.is_ascii() && (*self as u8).is_ascii_lowercase()
@ -1214,7 +1214,7 @@ impl char {
/// assert!(!lf.is_ascii_alphanumeric());
/// assert!(!esc.is_ascii_alphanumeric());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_alphanumeric(&self) -> bool {
self.is_ascii() && (*self as u8).is_ascii_alphanumeric()
@ -1248,7 +1248,7 @@ impl char {
/// assert!(!lf.is_ascii_digit());
/// assert!(!esc.is_ascii_digit());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_digit(&self) -> bool {
self.is_ascii() && (*self as u8).is_ascii_digit()
@ -1285,7 +1285,7 @@ impl char {
/// assert!(!lf.is_ascii_hexdigit());
/// assert!(!esc.is_ascii_hexdigit());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_hexdigit(&self) -> bool {
self.is_ascii() && (*self as u8).is_ascii_hexdigit()
@ -1323,7 +1323,7 @@ impl char {
/// assert!(!lf.is_ascii_punctuation());
/// assert!(!esc.is_ascii_punctuation());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_punctuation(&self) -> bool {
self.is_ascii() && (*self as u8).is_ascii_punctuation()
@ -1357,7 +1357,7 @@ impl char {
/// assert!(!lf.is_ascii_graphic());
/// assert!(!esc.is_ascii_graphic());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_graphic(&self) -> bool {
self.is_ascii() && (*self as u8).is_ascii_graphic()
@ -1408,7 +1408,7 @@ impl char {
/// assert!(lf.is_ascii_whitespace());
/// assert!(!esc.is_ascii_whitespace());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_whitespace(&self) -> bool {
self.is_ascii() && (*self as u8).is_ascii_whitespace()
@ -1444,7 +1444,7 @@ impl char {
/// assert!(lf.is_ascii_control());
/// assert!(esc.is_ascii_control());
/// ```
#[unstable(feature = "ascii_ctype", issue = "39658")]
#[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
#[inline]
pub fn is_ascii_control(&self) -> bool {
self.is_ascii() && (*self as u8).is_ascii_control()

1
src/test/compile-fail-fulldeps/dropck_tarena_cycle_checked.rs
View File

@ -17,7 +17,6 @@
// for the error message we see here.)
#![feature(rustc_private)]
#![feature(const_atomic_usize_new)]
extern crate arena;

24
src/test/compile-fail/const-fn-feature-flags.rs
View File

@ -1,24 +0,0 @@
// Copyright 2015 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.
// Test use of const fns in std using individual feature gates.
use std::cell::Cell;
const CELL: Cell<i32> = Cell::new(42); //~ERROR not yet stable as a const fn
//~^HELP #![feature(const_cell_new)]
fn main() {
let v = CELL.get();
CELL.set(v+1);
assert_eq!(CELL.get(), v);
}

2
src/test/compile-fail/dropck_trait_cycle_checked.rs
View File

@ -13,8 +13,6 @@
//
// (Compare against compile-fail/dropck_vec_cycle_checked.rs)
#![feature(const_atomic_usize_new)]
use std::cell::Cell;
use id::Id;

2
src/test/compile-fail/issue-17718-const-borrow.rs
View File

@ -8,8 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(const_unsafe_cell_new)]
use std::cell::UnsafeCell;
const A: UnsafeCell<usize> = UnsafeCell::new(1);

2
src/test/compile-fail/issue-43733-2.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(const_fn, const_cell_new, const_unsafe_cell_new)]
#![feature(const_fn)]
#![feature(cfg_target_thread_local, thread_local_internals)]
// On platforms *without* `#[thread_local]`, use

2
src/test/compile-fail/issue-7364.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(box_syntax, const_refcell_new)]
#![feature(box_syntax)]
use std::cell::RefCell;

1
src/test/debuginfo/constant-debug-locs.rs
View File

@ -15,7 +15,6 @@
#![allow(dead_code, unused_variables)]
#![feature(omit_gdb_pretty_printer_section)]
#![omit_gdb_pretty_printer_section]
#![feature(const_unsafe_cell_new)]
#![feature(static_mutex)]
// This test makes sure that the compiler doesn't crash when trying to assign

1
src/test/run-pass-fulldeps/vector-sort-panic-safe.rs
View File

@ -12,7 +12,6 @@
#![feature(rustc_private)]
#![feature(sort_unstable)]
#![feature(const_atomic_usize_new)]
extern crate rand;

1
src/test/run-pass-valgrind/cast-enum-with-dtor.rs
View File

@ -11,7 +11,6 @@
// no-prefer-dynamic
#![allow(dead_code)]
#![feature(const_atomic_usize_new)]
// check dtor calling order when casting enums.

2
src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where.rs
View File

@ -12,8 +12,6 @@
// `Item` originates in a where-clause, not the declaration of
// `T`. Issue #20300.
#![feature(const_atomic_usize_new)]
use std::marker::{PhantomData};
use std::sync::atomic::{AtomicUsize};
use std::sync::atomic::Ordering::SeqCst;

2
src/test/run-pass/auxiliary/issue-17718-aux.rs
View File

@ -8,8 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(const_atomic_usize_new)]
use std::sync::atomic;
pub const C1: usize = 1;

1
src/test/run-pass/auxiliary/thread-local-extern-static.rs
View File

@ -9,7 +9,6 @@
// except according to those terms.
#![feature(cfg_target_thread_local, const_fn, thread_local)]
#![feature(const_cell_new)]
#![crate_type = "lib"]
#[cfg(target_thread_local)]

2
src/test/run-pass/box-of-array-of-drop-1.rs
View File

@ -13,8 +13,6 @@
// ignore-emscripten no threads support
#![feature(const_atomic_usize_new)]
use std::thread;
use std::sync::atomic::{AtomicUsize, Ordering};

2
src/test/run-pass/box-of-array-of-drop-2.rs
View File

@ -13,8 +13,6 @@
// ignore-emscripten no threads support
#![feature(const_atomic_usize_new)]
use std::thread;
use std::sync::atomic::{AtomicUsize, Ordering};

4
src/test/run-pass/const-fn-feature-flags.rs
View File

@ -8,9 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Test use of const fns in std using individual feature gates.
#![feature(const_cell_new)]
// Test use of stabilized const fns in std formerly using individual feature gates.
use std::cell::Cell;

2
src/test/run-pass/const-size_of-align_of.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(const_fn, const_size_of, const_align_of)]
#![feature(const_fn)]
use std::mem;

3
src/test/run-pass/issue-17718-static-unsafe-interior.rs
View File

@ -10,9 +10,6 @@
// pretty-expanded FIXME #23616
#![feature(core)]
#![feature(const_unsafe_cell_new)]
use std::marker;
use std::cell::UnsafeCell;

4
src/test/run-pass/issue-17718.rs
View File

@ -10,10 +10,6 @@
// aux-build:issue-17718-aux.rs
#![feature(core)]
#![feature(const_atomic_usize_new)]
extern crate issue_17718_aux as other;
use std::sync::atomic::{AtomicUsize, Ordering};

2
src/test/run-pass/issue-21486.rs
View File

@ -12,8 +12,6 @@
// created via FRU and control-flow breaks in the middle of
// construction.
#![feature(const_atomic_usize_new)]
use std::sync::atomic::{Ordering, AtomicUsize};
#[derive(Debug)]

2
src/test/run-pass/issue-26655.rs
View File

@ -12,8 +12,6 @@
// Check that the destructors of simple enums are run on unwinding
#![feature(const_atomic_usize_new)]
use std::sync::atomic::{Ordering, AtomicUsize};
use std::thread;

2
src/test/run-pass/issue-27997.rs
View File

@ -8,8 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(const_atomic_usize_new)]
use std::sync::atomic::{Ordering, AtomicUsize};
use std::mem;

2
src/test/run-pass/nested-vec-3.rs
View File

@ -14,8 +14,6 @@
// the contents implement Drop and we hit a panic in the middle of
// construction.
#![feature(const_atomic_usize_new)]
use std::thread;
use std::sync::atomic::{AtomicUsize, Ordering};

1
src/test/run-pass/panic-handler-chain.rs
View File

@ -11,7 +11,6 @@
// ignore-emscripten no threads support
#![feature(panic_handler, std_panic)]
#![feature(const_atomic_usize_new)]
use std::sync::atomic::{AtomicUsize, Ordering};
use std::panic;

1
src/test/run-pass/panic-handler-set-twice.rs
View File

@ -8,7 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(panic_handler, std_panic)]
#![feature(const_atomic_usize_new)]
// ignore-emscripten no threads support

2
src/test/run-pass/struct-order-of-eval-3.rs
View File

@ -11,8 +11,6 @@
// Checks that functional-record-update order-of-eval is as expected
// even when no Drop-implementations are involved.
#![feature(const_atomic_usize_new)]
use std::sync::atomic::{Ordering, AtomicUsize};
struct W { wrapped: u32 }

2
src/test/run-pass/struct-order-of-eval-4.rs
View File

@ -11,8 +11,6 @@
// Checks that struct-literal expression order-of-eval is as expected
// even when no Drop-implementations are involved.
#![feature(const_atomic_usize_new)]
use std::sync::atomic::{Ordering, AtomicUsize};
struct W { wrapped: u32 }

2
src/test/ui/span/dropck_arr_cycle_checked.rs
View File

@ -13,7 +13,7 @@
//
// (Compare against compile-fail/dropck_vec_cycle_checked.rs)
#![feature(const_atomic_usize_new)]
use std::cell::Cell;
use id::Id;

2
src/test/ui/span/dropck_vec_cycle_checked.rs
View File

@ -12,7 +12,7 @@
//
// (Compare against compile-fail/dropck_arr_cycle_checked.rs)
#![feature(const_atomic_usize_new)]
use std::cell::Cell;
use id::Id;

2
src/test/ui/span/vec-must-not-hide-type-from-dropck.rs
View File

@ -23,7 +23,7 @@
// conditions above to be satisfied, meaning that if the dropck is
// sound, it should reject this code.
#![feature(const_atomic_usize_new)]
use std::cell::Cell;
use id::Id;