diff --git a/.travis.yml b/.travis.yml index 4ff548c4b80..320759b9233 100644 --- a/.travis.yml +++ b/.travis.yml @@ -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 diff --git a/src/liballoc/slice.rs b/src/liballoc/slice.rs index 7e3d2af79ce..0eee7fb722e 100644 --- a/src/liballoc/slice.rs +++ b/src/liballoc/slice.rs @@ -1428,15 +1428,45 @@ impl [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] { /// /// # 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] { /// /// # 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()) - } } //////////////////////////////////////////////////////////////////////////////// diff --git a/src/liballoc/str.rs b/src/liballoc/str.rs index 6e8515f0b36..9755c5d54f2 100644 --- a/src/liballoc/str.rs +++ b/src/liballoc/str.rs @@ -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 diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index d02576ae546..d4cd3f6264e 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -329,7 +329,6 @@ impl Cell { /// 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 { Cell { @@ -544,7 +543,6 @@ impl RefCell { /// 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 { RefCell { @@ -1215,7 +1213,6 @@ impl UnsafeCell { /// 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 { UnsafeCell { value: value } diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index c8218172583..ee989854a37 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -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, diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 631b9f98589..07b45ad6a50 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -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::*; diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index d57fbdf55f8..5b1a9399c39 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -311,7 +311,6 @@ pub fn forget(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() -> usize { unsafe { intrinsics::size_of::() } } @@ -403,7 +402,6 @@ pub fn min_align_of_val(val: &T) -> usize { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_const_unstable(feature = "const_align_of")] pub const fn align_of() -> usize { unsafe { intrinsics::min_align_of::() } } diff --git a/src/libcore/nonzero.rs b/src/libcore/nonzero.rs index ec277b4ae99..2c966eb3b57 100644 --- a/src/libcore/nonzero.rs +++ b/src/libcore/nonzero.rs @@ -70,7 +70,6 @@ impl NonZero { #[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) diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 19e91a65964..5b9dd4b1c69 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -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; } diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 19553d0c37b..5e70c8283f4 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -74,7 +74,6 @@ pub unsafe fn drop_in_place(to_drop: *mut T) { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_const_unstable(feature = "const_ptr_null")] pub const fn null() -> *const T { 0 as *const T } /// Creates a null mutable raw pointer. @@ -89,7 +88,6 @@ pub const fn null() -> *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() -> *mut T { 0 as *mut T } /// Swaps the values at two mutable locations of the same type, without @@ -2347,7 +2345,6 @@ impl Unique { /// /// `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 Shared { /// /// `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 } } diff --git a/src/libcore/sync/atomic.rs b/src/libcore/sync/atomic.rs index 8a261b8f077..4c6ff4d1bb4 100644 --- a/src/libcore/sync/atomic.rs +++ b/src/libcore/sync/atomic.rs @@ -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 AtomicPtr { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_unstable(feature = "const_atomic_ptr_new")] pub const fn new(p: *mut T) -> AtomicPtr { AtomicPtr { p: UnsafeCell::new(p) } } @@ -926,6 +924,13 @@ impl AtomicPtr { } } +#[cfg(target_has_atomic = "8")] +#[stable(feature = "atomic_bool_from", since = "1.24.0")] +impl From 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 From<*mut T> for AtomicPtr { @@ -935,7 +940,7 @@ impl From<*mut T> for AtomicPtr { #[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"), diff --git a/src/libcore/tests/lib.rs b/src/libcore/tests/lib.rs index e2283a71a0a..0e445cdac35 100644 --- a/src/libcore/tests/lib.rs +++ b/src/libcore/tests/lib.rs @@ -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; diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index b59f7480476..a8c80aaa030 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -64,7 +64,6 @@ #![feature(underscore_lifetimes)] #![feature(trace_macros)] #![feature(test)] -#![feature(const_atomic_bool_new)] #![recursion_limit="512"] diff --git a/src/librustc_apfloat/lib.rs b/src/librustc_apfloat/lib.rs index 09c9cecdcee..7dea3dae0bc 100644 --- a/src/librustc_apfloat/lib.rs +++ b/src/librustc_apfloat/lib.rs @@ -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)] diff --git a/src/librustc_const_eval/lib.rs b/src/librustc_const_eval/lib.rs index 714cead4bef..5e569e21de7 100644 --- a/src/librustc_const_eval/lib.rs +++ b/src/librustc_const_eval/lib.rs @@ -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; diff --git a/src/librustc_const_math/lib.rs b/src/librustc_const_math/lib.rs index c6893acb31f..095b8bb50dc 100644 --- a/src/librustc_const_math/lib.rs +++ b/src/librustc_const_math/lib.rs @@ -22,9 +22,6 @@ #![feature(i128)] #![feature(i128_type)] -#![feature(const_min_value)] -#![feature(const_max_value)] - extern crate rustc_apfloat; extern crate syntax; diff --git a/src/librustc_mir/diagnostics.rs b/src/librustc_mir/diagnostics.rs index 0f67f7bf6de..619c0dc847e 100644 --- a/src/librustc_mir/diagnostics.rs +++ b/src/librustc_mir/diagnostics.rs @@ -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 = 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; diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs index 923d93587e9..3d1bd81fe21 100644 --- a/src/librustc_trans/lib.rs +++ b/src/librustc_trans/lib.rs @@ -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; diff --git a/src/librustc_trans/llvm_util.rs b/src/librustc_trans/llvm_util.rs index 68e05d43044..a9ea96134fa 100644 --- a/src/librustc_trans/llvm_util.rs +++ b/src/librustc_trans/llvm_util.rs @@ -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 { let target_machine = create_target_machine(sess); @@ -102,6 +104,7 @@ pub fn target_features(sess: &Session) -> Vec { "aarch64" => AARCH64_WHITELIST, "x86" | "x86_64" => X86_WHITELIST, "hexagon" => HEXAGON_WHITELIST, + "mips" | "mips64" => MIPS_WHITELIST, "powerpc" | "powerpc64" => POWERPC_WHITELIST, _ => &[], }; diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 96d719c528c..312da203574 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -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); +#[stable(feature = "rust1", since = "1.0.0")] +impl AsciiExt for [u8] { + type Owned = Vec; + + 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] diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 9587bb424bd..bf177ac7f2c 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -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] diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index 8d7f60f9d2c..2dd3aebe610 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/src/libstd/sync/mpsc/mod.rs @@ -1297,11 +1297,72 @@ impl Receiver { 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 { + /// 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 { use self::RecvTimeoutError::*; loop { @@ -1625,7 +1686,7 @@ impl error::Error for TrySendError { } } -#[stable(feature = "mpsc_error_conversions", since = "1.23.0")] +#[stable(feature = "mpsc_error_conversions", since = "1.24.0")] impl From> for TrySendError { fn from(err: SendError) -> TrySendError { 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 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 for RecvTimeoutError { fn from(err: RecvError) -> RecvTimeoutError { match err { diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs index 2ef99525af5..6fd8b6a5bba 100644 --- a/src/libstd/sync/once.rs +++ b/src/libstd/sync/once.rs @@ -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), diff --git a/src/libstd_unicode/char.rs b/src/libstd_unicode/char.rs index 0faf5bd9121..6b573e5011b 100644 --- a/src/libstd_unicode/char.rs +++ b/src/libstd_unicode/char.rs @@ -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() diff --git a/src/test/compile-fail-fulldeps/dropck_tarena_cycle_checked.rs b/src/test/compile-fail-fulldeps/dropck_tarena_cycle_checked.rs index fa85432fb8e..bc88ff9244c 100644 --- a/src/test/compile-fail-fulldeps/dropck_tarena_cycle_checked.rs +++ b/src/test/compile-fail-fulldeps/dropck_tarena_cycle_checked.rs @@ -17,7 +17,6 @@ // for the error message we see here.) #![feature(rustc_private)] -#![feature(const_atomic_usize_new)] extern crate arena; diff --git a/src/test/compile-fail/const-fn-feature-flags.rs b/src/test/compile-fail/const-fn-feature-flags.rs deleted file mode 100644 index 823cb89b365..00000000000 --- a/src/test/compile-fail/const-fn-feature-flags.rs +++ /dev/null @@ -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 or the MIT license -// , 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 = 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); -} - diff --git a/src/test/compile-fail/dropck_trait_cycle_checked.rs b/src/test/compile-fail/dropck_trait_cycle_checked.rs index c0f0e3650d9..b6b7fa1a233 100644 --- a/src/test/compile-fail/dropck_trait_cycle_checked.rs +++ b/src/test/compile-fail/dropck_trait_cycle_checked.rs @@ -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; diff --git a/src/test/compile-fail/issue-17718-const-borrow.rs b/src/test/compile-fail/issue-17718-const-borrow.rs index 1464fcd9a1c..07123c69492 100644 --- a/src/test/compile-fail/issue-17718-const-borrow.rs +++ b/src/test/compile-fail/issue-17718-const-borrow.rs @@ -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 = UnsafeCell::new(1); diff --git a/src/test/compile-fail/issue-43733-2.rs b/src/test/compile-fail/issue-43733-2.rs index 1bf165c89d3..0fd31454596 100644 --- a/src/test/compile-fail/issue-43733-2.rs +++ b/src/test/compile-fail/issue-43733-2.rs @@ -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 diff --git a/src/test/compile-fail/issue-7364.rs b/src/test/compile-fail/issue-7364.rs index ef53be75780..3979790e3d4 100644 --- a/src/test/compile-fail/issue-7364.rs +++ b/src/test/compile-fail/issue-7364.rs @@ -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; diff --git a/src/test/debuginfo/constant-debug-locs.rs b/src/test/debuginfo/constant-debug-locs.rs index 7a24510b7d4..8fc910d8a6d 100644 --- a/src/test/debuginfo/constant-debug-locs.rs +++ b/src/test/debuginfo/constant-debug-locs.rs @@ -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 diff --git a/src/test/run-pass-fulldeps/vector-sort-panic-safe.rs b/src/test/run-pass-fulldeps/vector-sort-panic-safe.rs index 82305045f80..adc72aa0ea2 100644 --- a/src/test/run-pass-fulldeps/vector-sort-panic-safe.rs +++ b/src/test/run-pass-fulldeps/vector-sort-panic-safe.rs @@ -12,7 +12,6 @@ #![feature(rustc_private)] #![feature(sort_unstable)] -#![feature(const_atomic_usize_new)] extern crate rand; diff --git a/src/test/run-pass-valgrind/cast-enum-with-dtor.rs b/src/test/run-pass-valgrind/cast-enum-with-dtor.rs index 439c1080f47..4466a95cb39 100644 --- a/src/test/run-pass-valgrind/cast-enum-with-dtor.rs +++ b/src/test/run-pass-valgrind/cast-enum-with-dtor.rs @@ -11,7 +11,6 @@ // no-prefer-dynamic #![allow(dead_code)] -#![feature(const_atomic_usize_new)] // check dtor calling order when casting enums. diff --git a/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where.rs b/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where.rs index 7cde780cc54..5ceb1013ad8 100644 --- a/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where.rs +++ b/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where.rs @@ -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; diff --git a/src/test/run-pass/auxiliary/issue-17718-aux.rs b/src/test/run-pass/auxiliary/issue-17718-aux.rs index 36891a1ecad..2bc8b4b7ba0 100644 --- a/src/test/run-pass/auxiliary/issue-17718-aux.rs +++ b/src/test/run-pass/auxiliary/issue-17718-aux.rs @@ -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; diff --git a/src/test/run-pass/auxiliary/thread-local-extern-static.rs b/src/test/run-pass/auxiliary/thread-local-extern-static.rs index bce87ef5a26..e9457886be8 100644 --- a/src/test/run-pass/auxiliary/thread-local-extern-static.rs +++ b/src/test/run-pass/auxiliary/thread-local-extern-static.rs @@ -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)] diff --git a/src/test/run-pass/box-of-array-of-drop-1.rs b/src/test/run-pass/box-of-array-of-drop-1.rs index 47b44863a74..db055e6886a 100644 --- a/src/test/run-pass/box-of-array-of-drop-1.rs +++ b/src/test/run-pass/box-of-array-of-drop-1.rs @@ -13,8 +13,6 @@ // ignore-emscripten no threads support -#![feature(const_atomic_usize_new)] - use std::thread; use std::sync::atomic::{AtomicUsize, Ordering}; diff --git a/src/test/run-pass/box-of-array-of-drop-2.rs b/src/test/run-pass/box-of-array-of-drop-2.rs index 54be4955baf..9dde53bb31d 100644 --- a/src/test/run-pass/box-of-array-of-drop-2.rs +++ b/src/test/run-pass/box-of-array-of-drop-2.rs @@ -13,8 +13,6 @@ // ignore-emscripten no threads support -#![feature(const_atomic_usize_new)] - use std::thread; use std::sync::atomic::{AtomicUsize, Ordering}; diff --git a/src/test/run-pass/const-fn-feature-flags.rs b/src/test/run-pass/const-fn-feature-flags.rs index 1e27a3edac8..a7736a2eb34 100644 --- a/src/test/run-pass/const-fn-feature-flags.rs +++ b/src/test/run-pass/const-fn-feature-flags.rs @@ -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; diff --git a/src/test/run-pass/const-size_of-align_of.rs b/src/test/run-pass/const-size_of-align_of.rs index d5547ea5add..06fbe9bf4f6 100644 --- a/src/test/run-pass/const-size_of-align_of.rs +++ b/src/test/run-pass/const-size_of-align_of.rs @@ -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; diff --git a/src/test/run-pass/issue-17718-static-unsafe-interior.rs b/src/test/run-pass/issue-17718-static-unsafe-interior.rs index 66f70cdaeb0..5f7629fa267 100644 --- a/src/test/run-pass/issue-17718-static-unsafe-interior.rs +++ b/src/test/run-pass/issue-17718-static-unsafe-interior.rs @@ -10,9 +10,6 @@ // pretty-expanded FIXME #23616 -#![feature(core)] -#![feature(const_unsafe_cell_new)] - use std::marker; use std::cell::UnsafeCell; diff --git a/src/test/run-pass/issue-17718.rs b/src/test/run-pass/issue-17718.rs index 1b8fbc1ad2f..502e4a81664 100644 --- a/src/test/run-pass/issue-17718.rs +++ b/src/test/run-pass/issue-17718.rs @@ -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}; diff --git a/src/test/run-pass/issue-21486.rs b/src/test/run-pass/issue-21486.rs index 23d06c4324d..a61f294465d 100644 --- a/src/test/run-pass/issue-21486.rs +++ b/src/test/run-pass/issue-21486.rs @@ -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)] diff --git a/src/test/run-pass/issue-26655.rs b/src/test/run-pass/issue-26655.rs index 3e252b8629e..6d43451af6b 100644 --- a/src/test/run-pass/issue-26655.rs +++ b/src/test/run-pass/issue-26655.rs @@ -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; diff --git a/src/test/run-pass/issue-27997.rs b/src/test/run-pass/issue-27997.rs index dab42e48e16..9dba477a7e5 100644 --- a/src/test/run-pass/issue-27997.rs +++ b/src/test/run-pass/issue-27997.rs @@ -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; diff --git a/src/test/run-pass/nested-vec-3.rs b/src/test/run-pass/nested-vec-3.rs index 9141b5f29ce..d1a63b44392 100644 --- a/src/test/run-pass/nested-vec-3.rs +++ b/src/test/run-pass/nested-vec-3.rs @@ -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}; diff --git a/src/test/run-pass/panic-handler-chain.rs b/src/test/run-pass/panic-handler-chain.rs index c5dc8ccd2ee..8d692f2241b 100644 --- a/src/test/run-pass/panic-handler-chain.rs +++ b/src/test/run-pass/panic-handler-chain.rs @@ -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; diff --git a/src/test/run-pass/panic-handler-set-twice.rs b/src/test/run-pass/panic-handler-set-twice.rs index 8bf2683cd9f..81da13afaa5 100644 --- a/src/test/run-pass/panic-handler-set-twice.rs +++ b/src/test/run-pass/panic-handler-set-twice.rs @@ -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 diff --git a/src/test/run-pass/struct-order-of-eval-3.rs b/src/test/run-pass/struct-order-of-eval-3.rs index cf93133d205..3059c8e9e89 100644 --- a/src/test/run-pass/struct-order-of-eval-3.rs +++ b/src/test/run-pass/struct-order-of-eval-3.rs @@ -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 } diff --git a/src/test/run-pass/struct-order-of-eval-4.rs b/src/test/run-pass/struct-order-of-eval-4.rs index d442923478f..2ae9ebc34e1 100644 --- a/src/test/run-pass/struct-order-of-eval-4.rs +++ b/src/test/run-pass/struct-order-of-eval-4.rs @@ -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 } diff --git a/src/test/ui/span/dropck_arr_cycle_checked.rs b/src/test/ui/span/dropck_arr_cycle_checked.rs index 995a198271c..455c9dc57f5 100644 --- a/src/test/ui/span/dropck_arr_cycle_checked.rs +++ b/src/test/ui/span/dropck_arr_cycle_checked.rs @@ -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; diff --git a/src/test/ui/span/dropck_vec_cycle_checked.rs b/src/test/ui/span/dropck_vec_cycle_checked.rs index 5bcaa71f73c..5e7cb79680c 100644 --- a/src/test/ui/span/dropck_vec_cycle_checked.rs +++ b/src/test/ui/span/dropck_vec_cycle_checked.rs @@ -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; diff --git a/src/test/ui/span/vec-must-not-hide-type-from-dropck.rs b/src/test/ui/span/vec-must-not-hide-type-from-dropck.rs index d99f3bb19db..c4596e7c368 100644 --- a/src/test/ui/span/vec-must-not-hide-type-from-dropck.rs +++ b/src/test/ui/span/vec-must-not-hide-type-from-dropck.rs @@ -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;