From 1acd37fde5b07c66853b925d7d91dd3be6dc2a78 Mon Sep 17 00:00:00 2001 From: Dodo Date: Thu, 9 May 2019 20:30:36 +0200 Subject: [PATCH 01/11] make vecdeque_rotate stable --- src/liballoc/collections/vec_deque.rs | 8 ++------ src/liballoc/tests/lib.rs | 1 - 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/src/liballoc/collections/vec_deque.rs b/src/liballoc/collections/vec_deque.rs index d65c24f7350ae..7e7a854d2f339 100644 --- a/src/liballoc/collections/vec_deque.rs +++ b/src/liballoc/collections/vec_deque.rs @@ -1934,8 +1934,6 @@ impl VecDeque { /// # Examples /// /// ``` - /// #![feature(vecdeque_rotate)] - /// /// use std::collections::VecDeque; /// /// let mut buf: VecDeque<_> = (0..10).collect(); @@ -1949,7 +1947,7 @@ impl VecDeque { /// } /// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); /// ``` - #[unstable(feature = "vecdeque_rotate", issue = "56686")] + #[stable(feature = "vecdeque_rotate", since = "1.35.0")] pub fn rotate_left(&mut self, mid: usize) { assert!(mid <= self.len()); let k = self.len() - mid; @@ -1979,8 +1977,6 @@ impl VecDeque { /// # Examples /// /// ``` - /// #![feature(vecdeque_rotate)] - /// /// use std::collections::VecDeque; /// /// let mut buf: VecDeque<_> = (0..10).collect(); @@ -1994,7 +1990,7 @@ impl VecDeque { /// } /// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); /// ``` - #[unstable(feature = "vecdeque_rotate", issue = "56686")] + #[stable(feature = "vecdeque_rotate", since = "1.35.0")] pub fn rotate_right(&mut self, k: usize) { assert!(k <= self.len()); let mid = self.len() - k; diff --git a/src/liballoc/tests/lib.rs b/src/liballoc/tests/lib.rs index b736750c57601..ddb3120e89d78 100644 --- a/src/liballoc/tests/lib.rs +++ b/src/liballoc/tests/lib.rs @@ -6,7 +6,6 @@ #![feature(repeat_generic_slice)] #![feature(try_reserve)] #![feature(unboxed_closures)] -#![feature(vecdeque_rotate)] #![deny(rust_2018_idioms)] use std::hash::{Hash, Hasher}; From 4d033990fcb96023739a13c43e72b341de51e865 Mon Sep 17 00:00:00 2001 From: Dodo Date: Thu, 9 May 2019 20:50:02 +0200 Subject: [PATCH 02/11] supposed to be 1.36.0 --- src/liballoc/collections/vec_deque.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/liballoc/collections/vec_deque.rs b/src/liballoc/collections/vec_deque.rs index 7e7a854d2f339..65a888a970368 100644 --- a/src/liballoc/collections/vec_deque.rs +++ b/src/liballoc/collections/vec_deque.rs @@ -1947,7 +1947,7 @@ impl VecDeque { /// } /// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); /// ``` - #[stable(feature = "vecdeque_rotate", since = "1.35.0")] + #[stable(feature = "vecdeque_rotate", since = "1.36.0")] pub fn rotate_left(&mut self, mid: usize) { assert!(mid <= self.len()); let k = self.len() - mid; @@ -1990,7 +1990,7 @@ impl VecDeque { /// } /// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); /// ``` - #[stable(feature = "vecdeque_rotate", since = "1.35.0")] + #[stable(feature = "vecdeque_rotate", since = "1.36.0")] pub fn rotate_right(&mut self, k: usize) { assert!(k <= self.len()); let mid = self.len() - k; From a7a05203f18eac663ebf2751b77621c453dc280c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Richard=20Wiedenh=C3=B6ft?= Date: Mon, 29 Apr 2019 15:49:43 +0200 Subject: [PATCH 03/11] Mark core::alloc::Layout::from_size_align_unchecked const --- src/libcore/alloc.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcore/alloc.rs b/src/libcore/alloc.rs index c124457118cb9..302a9d89e5854 100644 --- a/src/libcore/alloc.rs +++ b/src/libcore/alloc.rs @@ -99,7 +99,7 @@ impl Layout { /// [`Layout::from_size_align`](#method.from_size_align). #[stable(feature = "alloc_layout", since = "1.28.0")] #[inline] - pub unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Self { + pub const unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Self { Layout { size_: size, align_: NonZeroUsize::new_unchecked(align) } } From 07e8d844795628ce90415c1dec3536f3e75cc71c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Richard=20Wiedenh=C3=B6ft?= Date: Tue, 30 Apr 2019 08:23:14 +0200 Subject: [PATCH 04/11] Add const_unchecked_layout test to libcore/tests --- src/libcore/tests/alloc.rs | 10 ++++++++++ src/libcore/tests/lib.rs | 2 ++ 2 files changed, 12 insertions(+) create mode 100644 src/libcore/tests/alloc.rs diff --git a/src/libcore/tests/alloc.rs b/src/libcore/tests/alloc.rs new file mode 100644 index 0000000000000..63537ba23d84d --- /dev/null +++ b/src/libcore/tests/alloc.rs @@ -0,0 +1,10 @@ +use core::alloc::Layout; + +#[test] +fn const_unchecked_layout() { + const SIZE: usize = 0x2000; + const ALIGN: usize = 0x1000; + const LAYOUT: Layout = unsafe { Layout::from_size_align_unchecked(SIZE, ALIGN) }; + assert_eq!(LAYOUT.size(), SIZE); + assert_eq!(LAYOUT.align(), ALIGN); +} diff --git a/src/libcore/tests/lib.rs b/src/libcore/tests/lib.rs index b8075ef2942e0..c617596aba801 100644 --- a/src/libcore/tests/lib.rs +++ b/src/libcore/tests/lib.rs @@ -31,10 +31,12 @@ #![feature(slice_partition_dedup)] #![feature(copy_within)] #![feature(int_error_matching)] +#![feature(const_fn)] #![warn(rust_2018_idioms)] extern crate test; +mod alloc; mod any; mod array; mod ascii; From c0b6d3c975915e740548f0ec7bcf5963e7a3b218 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Richard=20Wiedenh=C3=B6ft?= Date: Tue, 30 Apr 2019 12:56:38 +0200 Subject: [PATCH 05/11] Add ui test for const Layout::from_size_align_unchecked --- src/test/ui/consts/std/alloc.rs | 10 ++++++++++ src/test/ui/consts/std/alloc.stderr | 11 +++++++++++ 2 files changed, 21 insertions(+) create mode 100644 src/test/ui/consts/std/alloc.rs create mode 100644 src/test/ui/consts/std/alloc.stderr diff --git a/src/test/ui/consts/std/alloc.rs b/src/test/ui/consts/std/alloc.rs new file mode 100644 index 0000000000000..65ac7e44926d0 --- /dev/null +++ b/src/test/ui/consts/std/alloc.rs @@ -0,0 +1,10 @@ +use std::alloc::Layout; + +// ok +const LAYOUT_VALID: Layout = unsafe { Layout::from_size_align_unchecked(0x1000, 0x08) }; + +// not ok, since alignment needs to be non-zero. +const LAYOUT_INVALID: Layout = unsafe { Layout::from_size_align_unchecked(0x1000, 0x00) }; +//~^ ERROR it is undefined behavior to use this value + +fn main() {} diff --git a/src/test/ui/consts/std/alloc.stderr b/src/test/ui/consts/std/alloc.stderr new file mode 100644 index 0000000000000..74a8f3daf6aaa --- /dev/null +++ b/src/test/ui/consts/std/alloc.stderr @@ -0,0 +1,11 @@ +error[E0080]: it is undefined behavior to use this value + --> $DIR/alloc.rs:7:1 + | +LL | const LAYOUT_INVALID: Layout = unsafe { Layout::from_size_align_unchecked(0x1000, 0x00) }; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 0 at .align_, but expected something greater or equal to 1 + | + = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0080`. From 65b731908abee2bb8b0af50d18567eb4abaa4ac2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Fri, 17 May 2019 12:18:56 -0700 Subject: [PATCH 06/11] Explain that ? converts the error type using From --- src/librustc/traits/error_reporting.rs | 9 ++++++--- src/test/ui/issues/issue-32709.stderr | 1 + src/test/ui/try-block/try-block-bad-type.stderr | 1 + src/test/ui/try-on-option.stderr | 1 + 4 files changed, 9 insertions(+), 3 deletions(-) diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index df26883971022..9019c4a0575d4 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -643,13 +643,16 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { .map(|s| &s == "?") .unwrap_or(false); let is_from = format!("{}", trait_ref).starts_with("std::convert::From<"); - let message = if is_try && is_from { - Some(format!( + let (message, note) = if is_try && is_from { + (Some(format!( "`?` couldn't convert the error to `{}`", trait_ref.self_ty(), + )), Some( + "the question mark operation (`?`) implicitly performs a \ + conversion on the error value using the `From` trait".to_owned() )) } else { - message + (message, note) }; let mut err = struct_span_err!( diff --git a/src/test/ui/issues/issue-32709.stderr b/src/test/ui/issues/issue-32709.stderr index 84cca5b20af47..04b8c3aa35396 100644 --- a/src/test/ui/issues/issue-32709.stderr +++ b/src/test/ui/issues/issue-32709.stderr @@ -4,6 +4,7 @@ error[E0277]: `?` couldn't convert the error to `()` LL | Err(5)?; | ^ the trait `std::convert::From<{integer}>` is not implemented for `()` | + = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait = note: required by `std::convert::From::from` error: aborting due to previous error diff --git a/src/test/ui/try-block/try-block-bad-type.stderr b/src/test/ui/try-block/try-block-bad-type.stderr index 7c7366df1dc3e..e1c2c6b675e9b 100644 --- a/src/test/ui/try-block/try-block-bad-type.stderr +++ b/src/test/ui/try-block/try-block-bad-type.stderr @@ -4,6 +4,7 @@ error[E0277]: `?` couldn't convert the error to `i32` LL | Err("")?; | ^ the trait `std::convert::From<&str>` is not implemented for `i32` | + = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait = help: the following implementations were found: > > diff --git a/src/test/ui/try-on-option.stderr b/src/test/ui/try-on-option.stderr index 4465fbe14b75c..db5046f8c151a 100644 --- a/src/test/ui/try-on-option.stderr +++ b/src/test/ui/try-on-option.stderr @@ -4,6 +4,7 @@ error[E0277]: `?` couldn't convert the error to `()` LL | x?; | ^ the trait `std::convert::From` is not implemented for `()` | + = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait = note: required by `std::convert::From::from` error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `std::ops::Try`) From 90dd35918de13994cf06058de33860dfbd8ab51f Mon Sep 17 00:00:00 2001 From: Josh Stone Date: Fri, 17 May 2019 19:56:35 -0700 Subject: [PATCH 07/11] Use iter() for iterating arrays by slice These `into_iter()` calls will change from iterating references to values if we ever get `IntoIterator` for arrays, which may break the code using that iterator. Calling `iter()` is future proof. --- src/liballoc/tests/btree/set.rs | 4 ++-- src/libcore/iter/traits/iterator.rs | 32 ++++++++++++++--------------- src/librustdoc/config.rs | 2 +- src/librustdoc/html/render.rs | 2 +- 4 files changed, 20 insertions(+), 20 deletions(-) diff --git a/src/liballoc/tests/btree/set.rs b/src/liballoc/tests/btree/set.rs index d52814118b3c7..989beb3b1bfd9 100644 --- a/src/liballoc/tests/btree/set.rs +++ b/src/liballoc/tests/btree/set.rs @@ -143,8 +143,8 @@ fn test_union() { #[test] // Only tests the simple function definition with respect to intersection fn test_is_disjoint() { - let one = [1].into_iter().collect::>(); - let two = [2].into_iter().collect::>(); + let one = [1].iter().collect::>(); + let two = [2].iter().collect::>(); assert!(one.is_disjoint(&two)); } diff --git a/src/libcore/iter/traits/iterator.rs b/src/libcore/iter/traits/iterator.rs index 403f335810532..38c7c9bc4d086 100644 --- a/src/libcore/iter/traits/iterator.rs +++ b/src/libcore/iter/traits/iterator.rs @@ -356,7 +356,7 @@ pub trait Iterator { /// /// ``` /// let a = [0, 1, 2, 3, 4, 5]; - /// let mut iter = a.into_iter().step_by(2); + /// let mut iter = a.iter().step_by(2); /// /// assert_eq!(iter.next(), Some(&0)); /// assert_eq!(iter.next(), Some(&2)); @@ -531,7 +531,7 @@ pub trait Iterator { /// ``` /// let a = [1, 2, 3]; /// - /// let mut iter = a.into_iter().map(|x| 2 * x); + /// let mut iter = a.iter().map(|x| 2 * x); /// /// assert_eq!(iter.next(), Some(2)); /// assert_eq!(iter.next(), Some(4)); @@ -620,7 +620,7 @@ pub trait Iterator { /// ``` /// let a = [0i32, 1, 2]; /// - /// let mut iter = a.into_iter().filter(|x| x.is_positive()); + /// let mut iter = a.iter().filter(|x| x.is_positive()); /// /// assert_eq!(iter.next(), Some(&1)); /// assert_eq!(iter.next(), Some(&2)); @@ -634,7 +634,7 @@ pub trait Iterator { /// ``` /// let a = [0, 1, 2]; /// - /// let mut iter = a.into_iter().filter(|x| **x > 1); // need two *s! + /// let mut iter = a.iter().filter(|x| **x > 1); // need two *s! /// /// assert_eq!(iter.next(), Some(&2)); /// assert_eq!(iter.next(), None); @@ -646,7 +646,7 @@ pub trait Iterator { /// ``` /// let a = [0, 1, 2]; /// - /// let mut iter = a.into_iter().filter(|&x| *x > 1); // both & and * + /// let mut iter = a.iter().filter(|&x| *x > 1); // both & and * /// /// assert_eq!(iter.next(), Some(&2)); /// assert_eq!(iter.next(), None); @@ -657,7 +657,7 @@ pub trait Iterator { /// ``` /// let a = [0, 1, 2]; /// - /// let mut iter = a.into_iter().filter(|&&x| x > 1); // two &s + /// let mut iter = a.iter().filter(|&&x| x > 1); // two &s /// /// assert_eq!(iter.next(), Some(&2)); /// assert_eq!(iter.next(), None); @@ -837,7 +837,7 @@ pub trait Iterator { /// ``` /// let a = [-1i32, 0, 1]; /// - /// let mut iter = a.into_iter().skip_while(|x| x.is_negative()); + /// let mut iter = a.iter().skip_while(|x| x.is_negative()); /// /// assert_eq!(iter.next(), Some(&0)); /// assert_eq!(iter.next(), Some(&1)); @@ -851,7 +851,7 @@ pub trait Iterator { /// ``` /// let a = [-1, 0, 1]; /// - /// let mut iter = a.into_iter().skip_while(|x| **x < 0); // need two *s! + /// let mut iter = a.iter().skip_while(|x| **x < 0); // need two *s! /// /// assert_eq!(iter.next(), Some(&0)); /// assert_eq!(iter.next(), Some(&1)); @@ -863,7 +863,7 @@ pub trait Iterator { /// ``` /// let a = [-1, 0, 1, -2]; /// - /// let mut iter = a.into_iter().skip_while(|x| **x < 0); + /// let mut iter = a.iter().skip_while(|x| **x < 0); /// /// assert_eq!(iter.next(), Some(&0)); /// assert_eq!(iter.next(), Some(&1)); @@ -898,7 +898,7 @@ pub trait Iterator { /// ``` /// let a = [-1i32, 0, 1]; /// - /// let mut iter = a.into_iter().take_while(|x| x.is_negative()); + /// let mut iter = a.iter().take_while(|x| x.is_negative()); /// /// assert_eq!(iter.next(), Some(&-1)); /// assert_eq!(iter.next(), None); @@ -911,7 +911,7 @@ pub trait Iterator { /// ``` /// let a = [-1, 0, 1]; /// - /// let mut iter = a.into_iter().take_while(|x| **x < 0); // need two *s! + /// let mut iter = a.iter().take_while(|x| **x < 0); // need two *s! /// /// assert_eq!(iter.next(), Some(&-1)); /// assert_eq!(iter.next(), None); @@ -922,7 +922,7 @@ pub trait Iterator { /// ``` /// let a = [-1, 0, 1, -2]; /// - /// let mut iter = a.into_iter().take_while(|x| **x < 0); + /// let mut iter = a.iter().take_while(|x| **x < 0); /// /// assert_eq!(iter.next(), Some(&-1)); /// @@ -937,7 +937,7 @@ pub trait Iterator { /// /// ``` /// let a = [1, 2, 3, 4]; - /// let mut iter = a.into_iter(); + /// let mut iter = a.iter(); /// /// let result: Vec = iter.by_ref() /// .take_while(|n| **n != 3) @@ -1321,7 +1321,7 @@ pub trait Iterator { /// ``` /// let a = [1, 2, 3]; /// - /// let iter = a.into_iter(); + /// let iter = a.iter(); /// /// let sum: i32 = iter.take(5).fold(0, |acc, i| acc + i ); /// @@ -1334,7 +1334,7 @@ pub trait Iterator { /// // let's try that again /// let a = [1, 2, 3]; /// - /// let mut iter = a.into_iter(); + /// let mut iter = a.iter(); /// /// // instead, we add in a .by_ref() /// let sum: i32 = iter.by_ref().take(2).fold(0, |acc, i| acc + i ); @@ -1479,7 +1479,7 @@ pub trait Iterator { /// let a = [1, 2, 3]; /// /// let (even, odd): (Vec, Vec) = a - /// .into_iter() + /// .iter() /// .partition(|&n| n % 2 == 0); /// /// assert_eq!(even, vec![2]); diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs index 72421c9decc6f..4fae7e080b14a 100644 --- a/src/librustdoc/config.rs +++ b/src/librustdoc/config.rs @@ -538,7 +538,7 @@ fn check_deprecated_options(matches: &getopts::Matches, diag: &errors::Handler) "passes", ]; - for flag in deprecated_flags.into_iter() { + for flag in deprecated_flags.iter() { if matches.opt_present(flag) { let mut err = diag.struct_warn(&format!("the '{}' flag is considered deprecated", flag)); diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 0207fcda9e880..964789224ded2 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -506,7 +506,7 @@ pub fn initial_ids() -> Vec { "methods", "deref-methods", "implementations", - ].into_iter().map(|id| (String::from(*id))).collect() + ].iter().map(|id| (String::from(*id))).collect() } /// Generates the documentation for `crate` into the directory `dst` From b18de520800e2985e3313ca9ac21d5099d869428 Mon Sep 17 00:00:00 2001 From: Fabian Drinck Date: Sat, 18 May 2019 13:19:33 +0200 Subject: [PATCH 08/11] Declare DefIndex with the newtype_index macro --- src/librustc/hir/def_id.rs | 46 +++++-------------- src/librustc/hir/map/collector.rs | 2 +- src/librustc/hir/map/definitions.rs | 18 ++++---- src/librustc/hir/map/mod.rs | 4 +- .../infer/lexical_region_resolve/graphviz.rs | 4 +- src/librustc/traits/specialize/mod.rs | 2 +- src/librustc_driver/pretty.rs | 2 +- src/librustc_metadata/decoder.rs | 2 +- src/librustc_metadata/encoder.rs | 2 +- src/librustc_metadata/index.rs | 4 +- src/librustc_mir/util/graphviz.rs | 2 +- src/librustc_resolve/macros.rs | 2 +- src/librustc_save_analysis/lib.rs | 2 +- src/librustdoc/core.rs | 2 +- 14 files changed, 36 insertions(+), 58 deletions(-) diff --git a/src/librustc/hir/def_id.rs b/src/librustc/hir/def_id.rs index b268a1a494d10..0c4f5fb3fc167 100644 --- a/src/librustc/hir/def_id.rs +++ b/src/librustc/hir/def_id.rs @@ -96,34 +96,20 @@ impl fmt::Display for CrateNum { impl serialize::UseSpecializedEncodable for CrateNum {} impl serialize::UseSpecializedDecodable for CrateNum {} -/// A DefIndex is an index into the hir-map for a crate, identifying a -/// particular definition. It should really be considered an interned -/// shorthand for a particular DefPath. -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)] -pub struct DefIndex(u32); - -/// The crate root is always assigned index 0 by the AST Map code, -/// thanks to `NodeCollector::new`. -pub const CRATE_DEF_INDEX: DefIndex = DefIndex(0); +newtype_index! { + /// A DefIndex is an index into the hir-map for a crate, identifying a + /// particular definition. It should really be considered an interned + /// shorthand for a particular DefPath. + pub struct DefIndex { + DEBUG_FORMAT = "DefIndex({})", -impl fmt::Debug for DefIndex { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "DefIndex({})", self.as_array_index()) + /// The crate root is always assigned index 0 by the AST Map code, + /// thanks to `NodeCollector::new`. + const CRATE_DEF_INDEX = 0, } } impl DefIndex { - /// Converts this DefIndex into a zero-based array index. - #[inline] - pub fn as_array_index(&self) -> usize { - self.0 as usize - } - - #[inline] - pub fn from_array_index(i: usize) -> DefIndex { - DefIndex(i as u32) - } - // Proc macros from a proc-macro crate have a kind of virtual DefIndex. This // function maps the index of the macro within the crate (which is also the // index of the macro in the CrateMetadata::proc_macros array) to the @@ -132,7 +118,7 @@ impl DefIndex { // DefIndex for proc macros start from FIRST_FREE_DEF_INDEX, // because the first FIRST_FREE_DEF_INDEX indexes are reserved // for internal use. - let def_index = DefIndex::from_array_index( + let def_index = DefIndex::from( proc_macro_index.checked_add(FIRST_FREE_DEF_INDEX) .expect("integer overflow adding `proc_macro_index`")); assert!(def_index != CRATE_DEF_INDEX); @@ -141,19 +127,11 @@ impl DefIndex { // This function is the reverse of from_proc_macro_index() above. pub fn to_proc_macro_index(self: DefIndex) -> usize { - self.as_array_index().checked_sub(FIRST_FREE_DEF_INDEX) + self.index().checked_sub(FIRST_FREE_DEF_INDEX) .unwrap_or_else(|| { bug!("using local index {:?} as proc-macro index", self) }) } - - pub fn from_raw_u32(x: u32) -> DefIndex { - DefIndex(x) - } - - pub fn as_raw_u32(&self) -> u32 { - self.0 - } } impl serialize::UseSpecializedEncodable for DefIndex {} @@ -169,7 +147,7 @@ pub struct DefId { impl fmt::Debug for DefId { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "DefId({}:{}", self.krate, self.index.as_array_index())?; + write!(f, "DefId({}:{}", self.krate, self.index.index())?; ty::tls::with_opt(|opt_tcx| { if let Some(tcx) = opt_tcx { diff --git a/src/librustc/hir/map/collector.rs b/src/librustc/hir/map/collector.rs index a1cf338bf12ea..eeba628b3bf21 100644 --- a/src/librustc/hir/map/collector.rs +++ b/src/librustc/hir/map/collector.rs @@ -226,7 +226,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> { fn insert_entry(&mut self, id: HirId, entry: Entry<'hir>) { debug!("hir_map: {:?} => {:?}", id, entry); - let local_map = &mut self.map[id.owner.as_array_index()]; + let local_map = &mut self.map[id.owner.index()]; let i = id.local_id.as_u32() as usize; if local_map.is_none() { *local_map = Some(IndexVec::with_capacity(i + 1)); diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs index 9cb85c4db4757..1cc9a2c0e8a1b 100644 --- a/src/librustc/hir/map/definitions.rs +++ b/src/librustc/hir/map/definitions.rs @@ -38,7 +38,7 @@ impl DefPathTable { def_path_hash: DefPathHash) -> DefIndex { let index = { - let index = DefIndex::from_array_index(self.index_to_key.len()); + let index = DefIndex::from(self.index_to_key.len()); debug!("DefPathTable::insert() - {:?} <-> {:?}", key, index); self.index_to_key.push(key); index @@ -49,17 +49,17 @@ impl DefPathTable { } pub fn next_id(&self) -> DefIndex { - DefIndex::from_array_index(self.index_to_key.len()) + DefIndex::from(self.index_to_key.len()) } #[inline(always)] pub fn def_key(&self, index: DefIndex) -> DefKey { - self.index_to_key[index.as_array_index()].clone() + self.index_to_key[index.index()].clone() } #[inline(always)] pub fn def_path_hash(&self, index: DefIndex) -> DefPathHash { - let ret = self.def_path_hashes[index.as_array_index()]; + let ret = self.def_path_hashes[index.index()]; debug!("def_path_hash({:?}) = {:?}", index, ret); return ret } @@ -74,7 +74,7 @@ impl DefPathTable { .map(|(index, &hash)| { let def_id = DefId { krate: cnum, - index: DefIndex::from_array_index(index), + index: DefIndex::from(index), }; (hash, def_id) }) @@ -387,7 +387,7 @@ impl Definitions { #[inline] pub fn as_local_node_id(&self, def_id: DefId) -> Option { if def_id.krate == LOCAL_CRATE { - let node_id = self.def_index_to_node[def_id.index.as_array_index()]; + let node_id = self.def_index_to_node[def_id.index.index()]; if node_id != ast::DUMMY_NODE_ID { return Some(node_id); } @@ -417,7 +417,7 @@ impl Definitions { #[inline] pub fn def_index_to_hir_id(&self, def_index: DefIndex) -> hir::HirId { - let node_id = self.def_index_to_node[def_index.as_array_index()]; + let node_id = self.def_index_to_node[def_index.index()]; self.node_to_hir_id[node_id] } @@ -508,7 +508,7 @@ impl Definitions { // Create the definition. let index = self.table.allocate(key, def_path_hash); - assert_eq!(index.as_array_index(), self.def_index_to_node.len()); + assert_eq!(index.index(), self.def_index_to_node.len()); self.def_index_to_node.push(node_id); // Some things for which we allocate DefIndices don't correspond to @@ -653,7 +653,7 @@ macro_rules! define_global_metadata_kind { .position(|k| *k == def_key) .unwrap(); - DefIndex::from_array_index(index) + DefIndex::from(index) } fn name(&self) -> Symbol { diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index b8ee98551a20e..4b94f772554e7 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -189,7 +189,7 @@ pub struct Map<'hir> { impl<'hir> Map<'hir> { #[inline] fn lookup(&self, id: HirId) -> Option<&Entry<'hir>> { - let local_map = self.map.get(id.owner.as_array_index())?; + let local_map = self.map.get(id.owner.index())?; local_map.as_ref()?.get(id.local_id)?.as_ref() } @@ -1023,7 +1023,7 @@ impl<'hir> Map<'hir> { local_map.iter_enumerated().filter_map(move |(i, entry)| entry.map(move |_| { // Reconstruct the HirId based on the 3 indices we used to find it HirId { - owner: DefIndex::from_array_index(array_index), + owner: DefIndex::from(array_index), local_id: i, } })) diff --git a/src/librustc/infer/lexical_region_resolve/graphviz.rs b/src/librustc/infer/lexical_region_resolve/graphviz.rs index 073a3f74422c6..1878afd581dd4 100644 --- a/src/librustc/infer/lexical_region_resolve/graphviz.rs +++ b/src/librustc/infer/lexical_region_resolve/graphviz.rs @@ -56,7 +56,7 @@ pub fn maybe_print_constraints_for<'a, 'gcx, 'tcx>( } let requested_node = env::var("RUST_REGION_GRAPH_NODE") - .ok().and_then(|s| s.parse().map(DefIndex::from_raw_u32).ok()); + .ok().and_then(|s| s.parse().map(DefIndex::from_u32).ok()); if requested_node.is_some() && requested_node != Some(context.index) { return; @@ -90,7 +90,7 @@ pub fn maybe_print_constraints_for<'a, 'gcx, 'tcx>( let mut new_str = String::new(); for c in output_template.chars() { if c == '%' { - new_str.push_str(&context.index.as_raw_u32().to_string()); + new_str.push_str(&context.index.as_u32().to_string()); } else { new_str.push(c); } diff --git a/src/librustc/traits/specialize/mod.rs b/src/librustc/traits/specialize/mod.rs index fc20735eb0f67..fdd1a821e31b5 100644 --- a/src/librustc/traits/specialize/mod.rs +++ b/src/librustc/traits/specialize/mod.rs @@ -298,7 +298,7 @@ pub(super) fn specialization_graph_provider<'a, 'tcx>( // negated `CrateNum` (so remote definitions are visited first) and then // by a flattened version of the `DefIndex`. trait_impls.sort_unstable_by_key(|def_id| { - (-(def_id.krate.as_u32() as i64), def_id.index.as_array_index()) + (-(def_id.krate.as_u32() as i64), def_id.index.index()) }); for impl_def_id in trait_impls { diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index c74ed5ec30c3c..812321ff5e6c3 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -648,7 +648,7 @@ fn print_flowgraph<'a, 'tcx, W: Write>(variants: Vec, // have to be user friendly. let name = format!( "hir_id_{}_{}", - hir_id.owner.as_array_index(), + hir_id.owner.index(), hir_id.local_id.index(), ); let lcfg = LabelledCFG { diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index e950c2815e9b4..d882fe6f27ecc 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -264,7 +264,7 @@ impl<'a, 'tcx> SpecializedDecoder for DecodeContext<'a, 'tcx> { impl<'a, 'tcx> SpecializedDecoder for DecodeContext<'a, 'tcx> { #[inline] fn specialized_decode(&mut self) -> Result { - Ok(DefIndex::from_raw_u32(self.read_u32()?)) + Ok(DefIndex::from_u32(self.read_u32()?)) } } diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index 0ac03526832b7..939aadcc9ec9b 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -134,7 +134,7 @@ impl<'a, 'tcx> SpecializedEncoder for EncodeContext<'a, 'tcx> { impl<'a, 'tcx> SpecializedEncoder for EncodeContext<'a, 'tcx> { #[inline] fn specialized_encode(&mut self, def_index: &DefIndex) -> Result<(), Self::Error> { - self.emit_u32(def_index.as_raw_u32()) + self.emit_u32(def_index.as_u32()) } } diff --git a/src/librustc_metadata/index.rs b/src/librustc_metadata/index.rs index 4c1e39cd0a9e1..934e871559c79 100644 --- a/src/librustc_metadata/index.rs +++ b/src/librustc_metadata/index.rs @@ -93,7 +93,7 @@ impl Index { pub fn record_index(&mut self, item: DefIndex, entry: Lazy>) { assert!(entry.position < (u32::MAX as usize)); let position = entry.position as u32; - let array_index = item.as_array_index(); + let array_index = item.index(); let positions = &mut self.positions; assert!(u32::read_from_bytes_at(positions, array_index) == u32::MAX, @@ -126,7 +126,7 @@ impl<'tcx> LazySeq { def_index, self.len); - let position = u32::read_from_bytes_at(bytes, 1 + def_index.as_array_index()); + let position = u32::read_from_bytes_at(bytes, 1 + def_index.index()); if position == u32::MAX { debug!("Index::lookup: position=u32::MAX"); None diff --git a/src/librustc_mir/util/graphviz.rs b/src/librustc_mir/util/graphviz.rs index 188da9a82dc99..fc4c6b3fd3f24 100644 --- a/src/librustc_mir/util/graphviz.rs +++ b/src/librustc_mir/util/graphviz.rs @@ -27,7 +27,7 @@ pub fn graphviz_safe_def_name(def_id: DefId) -> String { format!( "{}_{}", def_id.krate.index(), - def_id.index.as_array_index(), + def_id.index.index(), ) } diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs index 9f3e1c308f637..e34a33ef8fad9 100644 --- a/src/librustc_resolve/macros.rs +++ b/src/librustc_resolve/macros.rs @@ -172,7 +172,7 @@ impl<'a> base::Resolver for Resolver<'a> { fn add_builtin(&mut self, ident: ast::Ident, ext: Lrc) { let def_id = DefId { krate: CrateNum::BuiltinMacros, - index: DefIndex::from_array_index(self.macro_map.len()), + index: DefIndex::from(self.macro_map.len()), }; let kind = ext.kind(); self.macro_map.insert(def_id, ext); diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index e03da2ed608be..d34f5633946bf 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -1170,7 +1170,7 @@ fn generated_code(span: Span) -> bool { fn id_from_def_id(id: DefId) -> rls_data::Id { rls_data::Id { krate: id.krate.as_u32(), - index: id.index.as_raw_u32(), + index: id.index.as_u32(), } } diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 428f4f328b907..2a3bc5e99617f 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -143,7 +143,7 @@ impl<'tcx> DocContext<'tcx> { crate_num, DefId { krate: crate_num, - index: DefIndex::from_array_index(def_id.index.as_array_index() + 1), + index: DefIndex::from(def_id.index.index() + 1), }, ); From 13a00963a6684455c129f19a643b65226f438f37 Mon Sep 17 00:00:00 2001 From: Brent Kerby Date: Sat, 18 May 2019 10:03:12 -0600 Subject: [PATCH 09/11] fix copy-paste typo in docs for ptr::read_volatile --- src/libcore/ptr.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index b6de9f57b0110..ada784e9ce705 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -837,7 +837,7 @@ pub unsafe fn write_unaligned(dst: *mut T, src: T) { /// /// * `src` must be properly aligned. /// -/// Like [`read`], `read_unaligned` creates a bitwise copy of `T`, regardless of +/// Like [`read`], `read_volatile` creates a bitwise copy of `T`, regardless of /// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned /// value and the value at `*src` can [violate memory safety][read-ownership]. /// However, storing non-[`Copy`] types in volatile memory is almost certainly From 01cf36ebde50521993a61013487059be5f568c19 Mon Sep 17 00:00:00 2001 From: Brent Kerby Date: Sat, 18 May 2019 12:38:06 -0600 Subject: [PATCH 10/11] Simplify BufRead doc example using NLL --- src/libstd/io/mod.rs | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 8fea6251e652a..917199f8ea8d0 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -1579,18 +1579,13 @@ pub trait BufRead: Read { /// let stdin = io::stdin(); /// let mut stdin = stdin.lock(); /// - /// // we can't have two `&mut` references to `stdin`, so use a block - /// // to end the borrow early. - /// let length = { - /// let buffer = stdin.fill_buf().unwrap(); + /// let buffer = stdin.fill_buf().unwrap(); /// - /// // work with buffer - /// println!("{:?}", buffer); - /// - /// buffer.len() - /// }; + /// // work with buffer + /// println!("{:?}", buffer); /// /// // ensure the bytes we worked with aren't returned again later + /// let length = buffer.len(); /// stdin.consume(length); /// ``` #[stable(feature = "rust1", since = "1.0.0")] From 86cda2d48e14f5cb755f54e6728bd9485d04713e Mon Sep 17 00:00:00 2001 From: Brent Kerby Date: Sat, 18 May 2019 16:22:59 -0600 Subject: [PATCH 11/11] Fix typos in docs of GlobalAlloc --- src/libcore/alloc.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libcore/alloc.rs b/src/libcore/alloc.rs index c124457118cb9..0451edec87b2b 100644 --- a/src/libcore/alloc.rs +++ b/src/libcore/alloc.rs @@ -480,7 +480,7 @@ pub unsafe trait GlobalAlloc { /// this allocator, /// /// * `layout` must be the same layout that was used - /// to allocated that block of memory, + /// to allocate that block of memory, #[stable(feature = "global_alloc", since = "1.28.0")] unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout); @@ -535,7 +535,7 @@ pub unsafe trait GlobalAlloc { /// * `ptr` must be currently allocated via this allocator, /// /// * `layout` must be the same layout that was used - /// to allocated that block of memory, + /// to allocate that block of memory, /// /// * `new_size` must be greater than zero. ///