Auto merge of #43939 - frewsxcv:rollup, r=frewsxcv

Rollup of 9 pull requests - Successful merges: #43891, #43905, #43912, #43914, #43915, #43916, #43920, #43928, #43930 - Failed merges:
rust-lang · Aug 17, 2017 · 59ccba9 · 59ccba9
2 parents dd39ecf + 235fb23
commit 59ccba9
Show file tree

Hide file tree

Showing 57 changed files with 129 additions and 75 deletions.
diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs
@@ -257,7 +257,7 @@ impl<'a> Builder<'a> {
  Kind::Bench => describe!(check::Crate, check::CrateLibrustc),
  Kind::Doc => describe!(doc::UnstableBook, doc::UnstableBookGen, doc::TheBook,
  doc::Standalone, doc::Std, doc::Test, doc::Rustc, doc::ErrorIndex, doc::Nomicon,
- doc::Reference, doc::Rustdoc),
+ doc::Reference, doc::Rustdoc, doc::CargoBook),
  Kind::Dist => describe!(dist::Docs, dist::Mingw, dist::Rustc, dist::DebuggerScripts,
  dist::Std, dist::Analysis, dist::Src, dist::PlainSourceTarball, dist::Cargo,
  dist::Rls, dist::Extended, dist::HashSign),

diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs
@@ -240,6 +240,51 @@ impl Step for TheBook {
  }
 }
 
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct CargoBook {
+ target: Interned<String>,
+}
+
+impl Step for CargoBook {
+ type Output = ();
+ const DEFAULT: bool = true;
+
+ fn should_run(run: ShouldRun) -> ShouldRun {
+ let builder = run.builder;
+ run.path("src/doc/cargo").default_condition(builder.build.config.docs)
+ }
+
+ fn make_run(run: RunConfig) {
+ run.builder.ensure(CargoBook {
+ target: run.target,
+ });
+ }
+
+ /// Create a placeholder for the cargo documentation so that doc.rust-lang.org/cargo will
+ /// redirect to doc.crates.io. We want to publish doc.rust-lang.org/cargo in the paper
+ /// version of the book, but we don't want to rush the process of switching cargo's docs
+ /// over to mdbook and deploying them. When the cargo book is ready, this implementation
+ /// should build the mdbook instead of this redirect page.
+ fn run(self, builder: &Builder) {
+ let build = builder.build;
+ let out = build.doc_out(self.target);
+
+ let cargo_dir = out.join("cargo");
+ t!(fs::create_dir_all(&cargo_dir));
+
+ let index = cargo_dir.join("index.html");
+ let redirect_html = r#"
+ <html>
+ <head>
+ <meta http-equiv="refresh" content="0; URL='http://doc.crates.io'" />
+ </head>
+ </html>"#;
+
+ println!("Creating cargo book redirect page");
+ t!(t!(File::create(&index)).write_all(redirect_html.as_bytes()));
+ }
+}
+
 fn invoke_rustdoc(builder: &Builder, compiler: Compiler, target: Interned<String>, markdown: &str) {
  let build = builder.build;
  let out = build.doc_out(target);

diff --git a/src/bootstrap/lib.rs b/src/bootstrap/lib.rs
@@ -444,7 +444,7 @@ impl Build {
  }
 
  /// Returns the root output directory for all Cargo output in a given stage,
- /// running a particular compiler, wehther or not we're building the
+ /// running a particular compiler, whether or not we're building the
  /// standard library, and targeting the specified architecture.
  fn cargo_out(&self,
  compiler: Compiler,

diff --git a/src/bootstrap/native.rs b/src/bootstrap/native.rs
@@ -11,7 +11,7 @@
 //! Compilation of native dependencies like LLVM.
 //!
 //! Native projects like LLVM unfortunately aren't suited just yet for
-//! compilation in build scripts that Cargo has. This is because thie
+//! compilation in build scripts that Cargo has. This is because the
 //! compilation takes a *very* long time but also because we don't want to
 //! compile LLVM 3 times as part of a normal bootstrap (we want it cached).
 //!

diff --git a/src/doc/book b/src/doc/book
diff --git a/src/doc/nomicon b/src/doc/nomicon
diff --git a/src/liballoc/allocator.rs b/src/liballoc/allocator.rs
@@ -293,7 +293,7 @@ impl Layout {
  /// Creates a layout describing the record for `self` followed by
  /// `next` with no additional padding between the two. Since no
  /// padding is inserted, the alignment of `next` is irrelevant,
- /// and is not incoporated *at all* into the resulting layout.
+ /// and is not incorporated *at all* into the resulting layout.
  ///
  /// Returns `(k, offset)`, where `k` is layout of the concatenated
  /// record and `offset` is the relative location, in bytes, of the
@@ -528,7 +528,7 @@ pub unsafe trait Alloc {
  /// to allocate that block of memory.
  unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout);
 
- /// Allocator-specific method for signalling an out-of-memory
+ /// Allocator-specific method for signaling an out-of-memory
  /// condition.
  ///
  /// `oom` aborts the thread or process, optionally performing
@@ -539,7 +539,7 @@ pub unsafe trait Alloc {
  /// unsatisfied allocation request (signaled by an error such as
  /// `AllocErr::Exhausted`), and wish to abandon computation rather
  /// than attempt to recover locally. Such clients should pass the
- /// signalling error value back into `oom`, where the allocator
+ /// signaling error value back into `oom`, where the allocator
  /// may incorporate that error value into its diagnostic report
  /// before aborting.
  ///

diff --git a/src/liballoc/btree/node.rs b/src/liballoc/btree/node.rs
@@ -763,7 +763,7 @@ impl<Node: Copy, Type> Clone for Handle<Node, Type> {
 }
 
 impl<Node, Type> Handle<Node, Type> {
- /// Retrieves the node that contains the edge of key/value pair this handle pointes to.
+ /// Retrieves the node that contains the edge of key/value pair this handle points to.
  pub fn into_node(self) -> Node {
  self.node
  }

diff --git a/src/liballoc/raw_vec.rs b/src/liballoc/raw_vec.rs
@@ -544,12 +544,12 @@ impl<T, A: Alloc> RawVec<T, A> {
  /// Attempts to ensure that the buffer contains at least enough space to hold
  /// `used_cap + needed_extra_cap` elements. If it doesn't already have
  /// enough capacity, will reallocate in place enough space plus comfortable slack
- /// space to get amortized `O(1)` behaviour. Will limit this behaviour
+ /// space to get amortized `O(1)` behavior. Will limit this behaviour
  /// if it would needlessly cause itself to panic.
  ///
  /// If `used_cap` exceeds `self.cap()`, this may fail to actually allocate
  /// the requested space. This is not really unsafe, but the unsafe
- /// code *you* write that relies on the behaviour of this function may break.
+ /// code *you* write that relies on the behavior of this function may break.
  ///
  /// Returns true if the reallocation attempt has succeeded, or false otherwise.
  ///

diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
@@ -809,7 +809,7 @@ impl<T: ?Sized> RefCell<T> {
  /// [`borrow_mut`] method instead if `self` isn't mutable.
  ///
  /// Also, please be aware that this method is only for special circumstances and is usually
- /// not you want. In case of doubt, use [`borrow_mut`] instead.
+ /// not what you want. In case of doubt, use [`borrow_mut`] instead.
  ///
  /// [`borrow_mut`]: #method.borrow_mut
  ///

diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs
@@ -240,7 +240,12 @@ pub trait Hash {
 /// [`write_u8`]: #method.write_u8
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Hasher {
- /// Completes a round of hashing, producing the output hash generated.
+ /// Returns the hash value for the values written so far.
+ ///
+ /// Despite its name, the method does not reset the hasher’s internal
+ /// state. Additional [`write`]s will continue from the current value.
+ /// If you need to start a fresh hash value, you will have to create
+ /// a new hasher.
  ///
  /// # Examples
  ///
@@ -253,6 +258,8 @@ pub trait Hasher {
  ///
  /// println!("Hash is {:x}!", hasher.finish());
  /// ```
+ ///
+ /// ['write']: #tymethod.write
  #[stable(feature = "rust1", since = "1.0.0")]
  fn finish(&self) -> u64;
 

diff --git a/src/libcore/num/dec2flt/rawfp.rs b/src/libcore/num/dec2flt/rawfp.rs
@@ -102,10 +102,10 @@ pub trait RawFloat : Float + Copy + Debug + LowerExp
  /// The number of bits in the exponent.
  const EXP_BITS: u8;
 
- /// The number of bits in the singificand, *including* the hidden bit.
+ /// The number of bits in the significand, *including* the hidden bit.
  const SIG_BITS: u8;
 
- /// The number of bits in the singificand, *excluding* the hidden bit.
+ /// The number of bits in the significand, *excluding* the hidden bit.
  const EXPLICIT_SIG_BITS: u8;
 
  /// The maximum legal exponent in fractional representation.
@@ -123,7 +123,7 @@ pub trait RawFloat : Float + Copy + Debug + LowerExp
  /// `MIN_EXP` for integral representation, i.e., with the shift applied.
  const MIN_EXP_INT: i16;
 
- /// The maximum normalized singificand in integral representation.
+ /// The maximum normalized significand in integral representation.
  const MAX_SIG: u64;
 
  /// The minimal normalized significand in integral representation.

diff --git a/src/libcore/ops/try.rs b/src/libcore/ops/try.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/// A trait for customizing the behaviour of the `?` operator.
+/// A trait for customizing the behavior of the `?` operator.
 ///
 /// A type implementing `Try` is one that has a canonical way to view it
 /// in terms of a success/failure dichotomy. This trait allows both

diff --git a/src/libcore/sync/atomic.rs b/src/libcore/sync/atomic.rs
@@ -1632,7 +1632,7 @@ unsafe fn atomic_xor<T>(dst: *mut T, val: T, order: Ordering) -> T {
 ///
 /// pub fn lock(&self) {
 /// while !self.flag.compare_and_swap(false, true, Ordering::Relaxed) {}
-/// // This fence syncronizes-with store in `unlock`.
+/// // This fence synchronizes-with store in `unlock`.
 /// fence(Ordering::Acquire);
 /// }
 ///

diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs
@@ -11,7 +11,7 @@
 //! Generate files suitable for use with [Graphviz](http://www.graphviz.org/)
 //!
 //! The `render` function generates output (e.g. an `output.dot` file) for
-//! use with [Graphviz](http://www.graphviz.org/) by walking a labelled
+//! use with [Graphviz](http://www.graphviz.org/) by walking a labeled
 //! graph. (Graphviz can then automatically lay out the nodes and edges
 //! of the graph, and also optionally render the graph as an image or
 //! other [output formats](
@@ -150,7 +150,7 @@
 //!
 //! The output from this example renders four nodes that make up the
 //! Hasse-diagram for the subsets of the set `{x, y}`. Each edge is
-//! labelled with the &sube; character (specified using the HTML character
+//! labeled with the &sube; character (specified using the HTML character
 //! entity `&sube`).
 //!
 //! ```rust
@@ -789,7 +789,7 @@ mod tests {
  }
 
  struct LabelledGraph {
- /// The name for this graph. Used for labelling generated `digraph`.
+ /// The name for this graph. Used for labeling generated `digraph`.
  name: &'static str,
 
  /// Each node is an index into `node_labels`; these labels are

diff --git a/src/librand/distributions/gamma.rs b/src/librand/distributions/gamma.rs
@@ -254,7 +254,7 @@ impl IndependentSample<f64> for ChiSquared {
 
 /// The Fisher F distribution `F(m, n)`.
 ///
-/// This distribution is equivalent to the ratio of two normalised
+/// This distribution is equivalent to the ratio of two normalized
 /// chi-squared distributions, that is, `F(m,n) = (χ²(m)/m) /
 /// (χ²(n)/n)`.
 pub struct FisherF {

diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs
@@ -76,7 +76,7 @@ impl IsaacRng {
  rng
  }
 
- /// Initialises `self`. If `use_rsl` is true, then use the current value
+ /// Initializes `self`. If `use_rsl` is true, then use the current value
  /// of `rsl` as a seed, otherwise construct one algorithmically (not
  /// randomly).
  fn init(&mut self, use_rsl: bool) {
@@ -367,7 +367,7 @@ impl Isaac64Rng {
  rng
  }
 
- /// Initialises `self`. If `use_rsl` is true, then use the current value
+ /// Initializes `self`. If `use_rsl` is true, then use the current value
  /// of `rsl` as a seed, otherwise construct one algorithmically (not
  /// randomly).
  fn init(&mut self, use_rsl: bool) {

diff --git a/src/librand/lib.rs b/src/librand/lib.rs
@@ -180,7 +180,7 @@ pub trait Rng: Sized {
  /// This method does *not* have a requirement to bear any fixed
  /// relationship to the other methods, for example, it does *not*
  /// have to result in the same output as progressively filling
- /// `dest` with `self.gen::<u8>()`, and any such behaviour should
+ /// `dest` with `self.gen::<u8>()`, and any such behavior should
  /// not be relied upon.
  ///
  /// This method should guarantee that `dest` is entirely filled

diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs
@@ -24,7 +24,7 @@ pub struct ReseedingRng<R, Rsdr> {
  rng: R,
  generation_threshold: usize,
  bytes_generated: usize,
- /// Controls the behaviour when reseeding the RNG.
+ /// Controls the behavior when reseeding the RNG.
  pub reseeder: Rsdr,
 }
 

diff --git a/src/librustc/diagnostics.rs b/src/librustc/diagnostics.rs
@@ -362,6 +362,10 @@ Here are some simple examples of where you'll run into this error:
 struct Foo { x: &bool } // error
 struct Foo<'a> { x: &'a bool } // correct
 
+struct Bar { x: Foo }
+ ^^^ expected lifetime parameter
+struct Bar<'a> { x: Foo<'a> } // correct
+
 enum Bar { A(u8), B(&bool), } // error
 enum Bar<'a> { A(u8), B(&'a bool), } // correct
 

diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
@@ -731,7 +731,7 @@ impl<'hir> Map<'hir> {
 
  /// Returns the nearest enclosing scope. A scope is an item or block.
  /// FIXME it is not clear to me that all items qualify as scopes - statics
- /// and associated types probably shouldn't, for example. Behaviour in this
+ /// and associated types probably shouldn't, for example. Behavior in this
  /// regard should be expected to be highly unstable.
  pub fn get_enclosing_scope(&self, id: NodeId) -> Option<NodeId> {
  match self.walk_parent_nodes(id, |node| match *node {

diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs
@@ -24,7 +24,7 @@
 //! a span, but also more information so that we can generate a meaningful
 //! error message.
 //!
-//! Having a catalogue of all the different reasons an error can arise is
+//! Having a catalog of all the different reasons an error can arise is
 //! also useful for other reasons, like cross-referencing FAQs etc, though
 //! we are not really taking advantage of this yet.
 //!

diff --git a/src/librustc/infer/resolve.rs b/src/librustc/infer/resolve.rs
@@ -46,7 +46,7 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for OpportunisticTypeResolver<'a, 'g
 }
 
 /// The opportunistic type and region resolver is similar to the
-/// opportunistic type resolver, but also opportunistly resolves
+/// opportunistic type resolver, but also opportunistically resolves
 /// regions. It is useful for canonicalization.
 pub struct OpportunisticTypeAndRegionResolver<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
  infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,

diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
@@ -101,7 +101,7 @@ pub struct FutureIncompatibleInfo {
  pub reference: &'static str // e.g., a URL for an issue/PR/RFC or error code
 }
 
-/// The targed of the `by_name` map, which accounts for renaming/deprecation.
+/// The target of the `by_name` map, which accounts for renaming/deprecation.
 enum TargetLint {
  /// A direct lint target
  Id(LintId),

diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
@@ -72,7 +72,7 @@ use mir::transform::MirSource;
 /// (M1.): Misc extent of the whole `let a = ...;` statement.
 /// (M2.): Misc extent of the `f()` expression.
 /// (M3.): Misc extent of the `f().g(..)` expression.
-/// (M4.): Misc extent of the block labelled `'b:`.
+/// (M4.): Misc extent of the block labeled `'b:`.
 /// (M5.): Misc extent of the `let x = d();` statement
 /// (D6.): DestructionScope for temporaries created during M5.
 /// (R7.): Remainder extent for block `'b:`, stmt 0 (let x = ...).

diff --git a/src/librustc/mir/traversal.rs b/src/librustc/mir/traversal.rs
@@ -216,7 +216,7 @@ impl<'a, 'tcx> Iterator for Postorder<'a, 'tcx> {
 ///
 /// Reverse postorder is the reverse order of a postorder traversal.
 /// This is different to a preorder traversal and represents a natural
-/// linearisation of control-flow.
+/// linearization of control-flow.
 ///
 /// ```text
 ///

diff --git a/src/librustc/traits/fulfill.rs b/src/librustc/traits/fulfill.rs
@@ -37,7 +37,7 @@ impl<'tcx> ForestObligation for PendingPredicateObligation<'tcx> {
 /// consists of a list of obligations that must be (eventually)
 /// satisfied. The job is to track which are satisfied, which yielded
 /// errors, and which are still pending. At any point, users can call
-/// `select_where_possible`, and the fulfilment context will try to do
+/// `select_where_possible`, and the fulfillment context will try to do
 /// selection, retaining only those obligations that remain
 /// ambiguous. This may be helpful in pushing type inference
 /// along. Once all type inference constraints have been generated, the

diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
@@ -851,7 +851,7 @@ pub struct GlobalCtxt<'tcx> {
 
  /// A vector of every trait accessible in the whole crate
  /// (i.e. including those from subcrates). This is used only for
- /// error reporting, and so is lazily initialised and generally
+ /// error reporting, and so is lazily initialized and generally
  /// shouldn't taint the common path (hence the RefCell).
  pub all_traits: RefCell<Option<Vec<DefId>>>,
 }

diff --git a/src/librustc/ty/inhabitedness/def_id_forest.rs b/src/librustc/ty/inhabitedness/def_id_forest.rs
@@ -26,7 +26,7 @@ pub struct DefIdForest {
  /// The minimal set of DefIds required to represent the whole set.
  /// If A and B are DefIds in the DefIdForest, and A is a descendant
  /// of B, then only B will be in root_ids.
- /// We use a SmallVec here because (for its use for cacheing inhabitedness)
+ /// We use a SmallVec here because (for its use for caching inhabitedness)
  /// its rare that this will contain even two ids.
  root_ids: SmallVec<[DefId; 1]>,
 }

diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
@@ -739,7 +739,7 @@ pub type Region<'tcx> = &'tcx RegionKind;
 ///
 /// The process of doing that is called "skolemization". The bound regions
 /// are replaced by skolemized markers, which don't satisfy any relation
-/// not explicity provided.
+/// not explicitly provided.
 ///
 /// There are 2 kinds of skolemized regions in rustc: `ReFree` and
 /// `ReSkolemized`. When checking an item's body, `ReFree` is supposed

diff --git a/src/librustc_data_structures/accumulate_vec.rs b/src/librustc_data_structures/accumulate_vec.rs
@@ -13,7 +13,7 @@
 //! Space for up to N elements is provided on the stack. If more elements are collected, Vec is
 //! used to store the values on the heap.
 //!
-//! The N above is determined by Array's implementor, by way of an associatated constant.
+//! The N above is determined by Array's implementor, by way of an associated constant.
 
 use std::ops::{Deref, DerefMut};
 use std::iter::{self, IntoIterator, FromIterator};

diff --git a/src/librustc_data_structures/ivar.rs b/src/librustc_data_structures/ivar.rs
@@ -14,7 +14,7 @@ use std::cell::Cell;
 /// A write-once variable. When constructed, it is empty, and
 /// can only be set once.
 ///
-/// Ivars ensure that data that can only be initialised once. A full
+/// Ivars ensure that data that can only be initialized once. A full
 /// implementation is used for concurrency and blocks on a read of an
 /// unfulfilled value. This implementation is more minimal and panics
 /// if you attempt to read the value before it has been set. It is also