Rollup of 16 pull requests

Cargo.lock

@@ -2613,6 +2613,7 @@ dependencies = [
  "serialize 0.0.0",
  "syntax 0.0.0",
  "syntax_pos 0.0.0",
+ "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -3374,6 +3375,7 @@ dependencies = [
  "arena 0.0.0",
  "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc_data_structures 0.0.0",
+ "rustc_macros 0.1.0",
  "scoped-tls 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serialize 0.0.0",
  "unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

src/doc/rustc/src/command-line-arguments.md

@@ -86,6 +86,13 @@ This flag will set which lints should be set to the [deny level](lints/levels.ht
 
 This flag will set which lints should be set to the [forbid level](lints/levels.html#forbid).
 
+## `-Z`: set unstable options
+
+This flag will allow you to set unstable options of rustc. In order to set multiple options,
+the -Z flag can be used multiple times. For example: `rustc -Z verbose -Z time`.
+Specifying options with -Z is only available on nightly. To view all available options
+run: `rustc -Z help`.
+
 ## `--cap-lints`: set the most restrictive lint level
 
 This flag lets you 'cap' lints, for more, [see here](lints/levels.html#capping-lints).

src/libcore/cmp.rs

@@ -286,13 +286,13 @@ pub struct AssertParamIsEq<T: Eq + ?Sized> { _field: ::marker::PhantomData<T> }
 #[derive(Clone, Copy, PartialEq, Debug, Hash)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub enum Ordering {
- /// An ordering where a compared value is less [than another].
+ /// An ordering where a compared value is less than another.
  #[stable(feature = "rust1", since = "1.0.0")]
  Less = -1,
- /// An ordering where a compared value is equal [to another].
+ /// An ordering where a compared value is equal to another.
  #[stable(feature = "rust1", since = "1.0.0")]
  Equal = 0,
- /// An ordering where a compared value is greater [than another].
+ /// An ordering where a compared value is greater than another.
  #[stable(feature = "rust1", since = "1.0.0")]
  Greater = 1,
 }

src/libcore/ops/arith.rs

@@ -220,21 +220,21 @@ sub_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
 /// // derive `Eq` and `PartialEq`.
 /// #[derive(Debug, Eq, PartialEq)]
 /// struct Rational {
-/// nominator: usize,
+/// numerator: usize,
 /// denominator: usize,
 /// }
 ///
 /// impl Rational {
-/// fn new(nominator: usize, denominator: usize) -> Self {
+/// fn new(numerator: usize, denominator: usize) -> Self {
 /// if denominator == 0 {
 /// panic!("Zero is an invalid denominator!");
 /// }
 ///
 /// // Reduce to lowest terms by dividing by the greatest common
 /// // divisor.
-/// let gcd = gcd(nominator, denominator);
+/// let gcd = gcd(numerator, denominator);
 /// Rational {
-/// nominator: nominator / gcd,
+/// numerator: numerator / gcd,
 /// denominator: denominator / gcd,
 /// }
 /// }
@@ -245,9 +245,9 @@ sub_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
 /// type Output = Self;
 ///
 /// fn mul(self, rhs: Self) -> Self {
-/// let nominator = self.nominator * rhs.nominator;
+/// let numerator = self.numerator * rhs.numerator;
 /// let denominator = self.denominator * rhs.denominator;
-/// Rational::new(nominator, denominator)
+/// Rational::new(numerator, denominator)
 /// }
 /// }
 ///
@@ -340,21 +340,21 @@ mul_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
 /// // derive `Eq` and `PartialEq`.
 /// #[derive(Debug, Eq, PartialEq)]
 /// struct Rational {
-/// nominator: usize,
+/// numerator: usize,
 /// denominator: usize,
 /// }
 ///
 /// impl Rational {
-/// fn new(nominator: usize, denominator: usize) -> Self {
+/// fn new(numerator: usize, denominator: usize) -> Self {
 /// if denominator == 0 {
 /// panic!("Zero is an invalid denominator!");
 /// }
 ///
 /// // Reduce to lowest terms by dividing by the greatest common
 /// // divisor.
-/// let gcd = gcd(nominator, denominator);
+/// let gcd = gcd(numerator, denominator);
 /// Rational {
-/// nominator: nominator / gcd,
+/// numerator: numerator / gcd,
 /// denominator: denominator / gcd,
 /// }
 /// }
@@ -365,13 +365,13 @@ mul_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
 /// type Output = Self;
 ///
 /// fn div(self, rhs: Self) -> Self::Output {
-/// if rhs.nominator == 0 {
+/// if rhs.numerator == 0 {
 /// panic!("Cannot divide by zero-valued `Rational`!");
 /// }
 ///
-/// let nominator = self.nominator * rhs.denominator;
-/// let denominator = self.denominator * rhs.nominator;
-/// Rational::new(nominator, denominator)
+/// let numerator = self.numerator * rhs.denominator;
+/// let denominator = self.denominator * rhs.numerator;
+/// Rational::new(numerator, denominator)
 /// }
 /// }
 ///

src/libcore/task/wake.rs

@@ -72,10 +72,18 @@ pub struct RawWakerVTable {
  /// This function will be called when `wake` is called on the [`Waker`].
  /// It must wake up the task associated with this [`RawWaker`].
  ///
- /// The implemention of this function must not consume the provided data
- /// pointer.
+ /// The implementation of this function must make sure to release any
+ /// resources that are associated with this instance of a [`RawWaker`] and
+ /// associated task.
  wake: unsafe fn(*const ()),
 
+ /// This function will be called when `wake_by_ref` is called on the [`Waker`].
+ /// It must wake up the task associated with this [`RawWaker`].
+ ///
+ /// This function is similar to `wake`, but must not consume the provided data
+ /// pointer.
+ wake_by_ref: unsafe fn(*const ()),
+
  /// This function gets called when a [`RawWaker`] gets dropped.
  ///
  /// The implementation of this function must make sure to release any
@@ -85,8 +93,8 @@ pub struct RawWakerVTable {
 }
 
 impl RawWakerVTable {
- /// Creates a new `RawWakerVTable` from the provided `clone`, `wake`, and
- /// `drop` functions.
+ /// Creates a new `RawWakerVTable` from the provided `clone`, `wake`,
+ /// `wake_by_ref`, and `drop` functions.
  ///
  /// # `clone`
  ///
@@ -103,7 +111,16 @@ impl RawWakerVTable {
  /// This function will be called when `wake` is called on the [`Waker`].
  /// It must wake up the task associated with this [`RawWaker`].
  ///
- /// The implemention of this function must not consume the provided data
+ /// The implementation of this function must make sure to release any
+ /// resources that are associated with this instance of a [`RawWaker`] and
+ /// associated task.
+ ///
+ /// # `wake_by_ref`
+ ///
+ /// This function will be called when `wake_by_ref` is called on the [`Waker`].
+ /// It must wake up the task associated with this [`RawWaker`].
+ ///
+ /// This function is similar to `wake`, but must not consume the provided data
  /// pointer.
  ///
  /// # `drop`
@@ -120,11 +137,13 @@ impl RawWakerVTable {
  pub const fn new(
  clone: unsafe fn(*const ()) -> RawWaker,
  wake: unsafe fn(*const ()),
+ wake_by_ref: unsafe fn(*const ()),
  drop: unsafe fn(*const ()),
  ) -> Self {
  Self {
  clone,
  wake,
+ wake_by_ref,
  drop,
  }
  }
@@ -187,14 +206,33 @@ unsafe impl Sync for Waker {}
 impl Waker {
  /// Wake up the task associated with this `Waker`.
  #[inline]
- pub fn wake(&self) {
+ pub fn wake(self) {
  // The actual wakeup call is delegated through a virtual function call
  // to the implementation which is defined by the executor.
+ let wake = self.waker.vtable.wake;
+ let data = self.waker.data;
 
- // SAFETY: This is safe because `Waker::new_unchecked` is the only way
+ // Don't call `drop` -- the waker will be consumed by `wake`.
+ crate::mem::forget(self);
+
+ // SAFETY: This is safe because `Waker::from_raw` is the only way
  // to initialize `wake` and `data` requiring the user to acknowledge
  // that the contract of `RawWaker` is upheld.
- unsafe { (self.waker.vtable.wake)(self.waker.data) }
+ unsafe { (wake)(data) };
+ }
+
+ /// Wake up the task associated with this `Waker` without consuming the `Waker`.
+ ///
+ /// This is similar to `wake`, but may be slightly less efficient in the case
+ /// where an owned `Waker` is available. This method should be preferred to
+ /// calling `waker.clone().wake()`.
+ #[inline]
+ pub fn wake_by_ref(&self) {
+ // The actual wakeup call is delegated through a virtual function call
+ // to the implementation which is defined by the executor.
+
+ // SAFETY: see `wake`
+ unsafe { (self.waker.vtable.wake_by_ref)(self.waker.data) }
  }
 
  /// Returns `true` if this `Waker` and another `Waker` have awoken the same task.
@@ -215,7 +253,7 @@ impl Waker {
  /// in [`RawWaker`]'s and [`RawWakerVTable`]'s documentation is not upheld.
  /// Therefore this method is unsafe.
  #[inline]
- pub unsafe fn new_unchecked(waker: RawWaker) -> Waker {
+ pub unsafe fn from_raw(waker: RawWaker) -> Waker {
  Waker {
  waker,
  }
@@ -226,7 +264,7 @@ impl Clone for Waker {
  #[inline]
  fn clone(&self) -> Self {
  Waker {
- // SAFETY: This is safe because `Waker::new_unchecked` is the only way
+ // SAFETY: This is safe because `Waker::from_raw` is the only way
  // to initialize `clone` and `data` requiring the user to acknowledge
  // that the contract of [`RawWaker`] is upheld.
  waker: unsafe { (self.waker.vtable.clone)(self.waker.data) },
@@ -237,7 +275,7 @@ impl Clone for Waker {
 impl Drop for Waker {
  #[inline]
  fn drop(&mut self) {
- // SAFETY: This is safe because `Waker::new_unchecked` is the only way
+ // SAFETY: This is safe because `Waker::from_raw` is the only way
  // to initialize `drop` and `data` requiring the user to acknowledge
  // that the contract of `RawWaker` is upheld.
  unsafe { (self.waker.vtable.drop)(self.waker.data) }

src/librustc/hir/print.rs

@@ -622,7 +622,7 @@ impl<'a> State<'a> {
  }
  hir::ItemKind::GlobalAsm(ref ga) => {
  self.head(visibility_qualified(&item.vis, "global asm"))?;
- self.s.word(ga.asm.as_str().get())?;
+ self.s.word(ga.asm.as_str().to_string())?;
  self.end()?
  }
  hir::ItemKind::Ty(ref ty, ref generics) => {
@@ -1591,7 +1591,7 @@ impl<'a> State<'a> {
  if ident.is_raw_guess() {
  self.s.word(format!("r#{}", ident.name))?;
  } else {
- self.s.word(ident.as_str().get())?;
+ self.s.word(ident.as_str().to_string())?;
  }
  self.ann.post(self, AnnNode::Name(&ident.name))
  }
@@ -1998,7 +1998,7 @@ impl<'a> State<'a> {
  self.commasep(Inconsistent, &decl.inputs, |s, ty| {
  s.ibox(indent_unit)?;
  if let Some(arg_name) = arg_names.get(i) {
- s.s.word(arg_name.as_str().get())?;
+ s.s.word(arg_name.as_str().to_string())?;
  s.s.word(":")?;
  s.s.space()?;
  } else if let Some(body_id) = body_id {

src/librustc/middle/cstore.rs

@@ -199,6 +199,7 @@ pub trait CrateStore {
 
  // "queries" used in resolve that aren't tracked for incremental compilation
  fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol;
+ fn crate_is_private_dep_untracked(&self, cnum: CrateNum) -> bool;
  fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> CrateDisambiguator;
  fn crate_hash_untracked(&self, cnum: CrateNum) -> Svh;
  fn extern_mod_stmt_cnum_untracked(&self, emod_id: ast::NodeId) -> Option<CrateNum>;

src/librustc/middle/lib_features.rs

@@ -8,7 +8,7 @@ use crate::ty::TyCtxt;
 use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
 use syntax::symbol::Symbol;
 use syntax::ast::{Attribute, MetaItem, MetaItemKind};
-use syntax_pos::Span;
+use syntax_pos::{Span, symbols};
 use rustc_data_structures::fx::{FxHashSet, FxHashMap};
 use rustc_macros::HashStable;
 use errors::DiagnosticId;
@@ -51,12 +51,12 @@ impl<'a, 'tcx> LibFeatureCollector<'a, 'tcx> {
  }
 
  fn extract(&self, attr: &Attribute) -> Option<(Symbol, Option<Symbol>, Span)> {
- let stab_attrs = vec!["stable", "unstable", "rustc_const_unstable"];
+ let stab_attrs = [symbols::stable, symbols::unstable, symbols::rustc_const_unstable];
 
  // Find a stability attribute (i.e., `#[stable (..)]`, `#[unstable (..)]`,
  // `#[rustc_const_unstable (..)]`).
  if let Some(stab_attr) = stab_attrs.iter().find(|stab_attr| {
- attr.check_name(stab_attr)
+ attr.check_name(**stab_attr)
  }) {
  let meta_item = attr.meta();
  if let Some(MetaItem { node: MetaItemKind::List(ref metas), .. }) = meta_item {