Merge pull request #20674 from jbcrail/fix-misspelled-comments

Fix misspelled comments.

Reviewed-by: steveklabnik

Author: bors

src/doc/reference.md

@@ -1218,7 +1218,7 @@ the guarantee that these issues are never caused by safe code.
     (`offset` intrinsic), with
     the exception of one byte past the end which is permitted.
   * Using `std::ptr::copy_nonoverlapping_memory` (`memcpy32`/`memcpy64`
-    instrinsics) on overlapping buffers
+    intrinsics) on overlapping buffers
 * Invalid values in primitive types, even in private fields/locals:
   * Dangling/null references or boxes
   * A value other than `false` (0) or `true` (1) in a `bool`

src/libcollections/btree/node.rs

@@ -1220,7 +1220,7 @@ impl<K, V> Node<K, V> {
     /// Node is full, so split it into two nodes, and yield the middle-most key-value pair
     /// because we have one too many, and our parent now has one too few
     fn split(&mut self) -> (K, V, Node<K, V>) {
-        // Necessary for correctness, but in a private funtion
+        // Necessary for correctness, but in a private function
         debug_assert!(self.len() > 0);
 
         let mut right = if self.is_leaf() {
@@ -1259,7 +1259,7 @@ impl<K, V> Node<K, V> {
         }
     }
 
-    /// Take all the values from right, seperated by the given key and value
+    /// Take all the values from right, separated by the given key and value
     fn absorb(&mut self, key: K, val: V, mut right: Node<K, V>) {
         // Necessary for correctness, but in a private function
         // Just as a sanity check, make sure we can fit this guy in

src/libcollections/slice.rs

@@ -987,7 +987,7 @@ impl<T> SliceExt for [T] {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Extension traits for slices over specifc kinds of data
+// Extension traits for slices over specific kinds of data
 ////////////////////////////////////////////////////////////////////////////////
 #[unstable = "U should be an associated type"]
 /// An extension trait for concatenating slices
@@ -997,7 +997,7 @@ pub trait SliceConcatExt<T: ?Sized, U> {
     fn concat(&self) -> U;
 
     /// Flattens a slice of `T` into a single value `U`, placing a
-    /// given seperator between each.
+    /// given separator between each.
     #[stable]
     fn connect(&self, sep: &T) -> U;
 }

src/libcore/ptr.rs

@@ -97,7 +97,7 @@ use marker::{Send, Sized, Sync};
 use cmp::{PartialEq, Eq, Ord, PartialOrd};
 use cmp::Ordering::{self, Less, Equal, Greater};
 
-// FIXME #19649: instrinsic docs don't render, so these have no docs :(
+// FIXME #19649: intrinsic docs don't render, so these have no docs :(
 
 #[unstable]
 pub use intrinsics::copy_nonoverlapping_memory;
@@ -233,7 +233,7 @@ pub unsafe fn read_and_zero<T>(dest: *mut T) -> T {
 /// not drop the contents of `dst`. This could leak allocations or resources,
 /// so care must be taken not to overwrite an object that should be dropped.
 ///
-/// This is appropriate for initializing uninitialized memory, or overwritting
+/// This is appropriate for initializing uninitialized memory, or overwriting
 /// memory that has previously been `read` from.
 #[inline]
 #[stable]

src/librustc/metadata/encoder.rs

@@ -2034,7 +2034,7 @@ pub fn encode_metadata(parms: EncodeParams, krate: &ast::Crate) -> Vec<u8> {
 
     // And here we run into yet another obscure archive bug: in which metadata
     // loaded from archives may have trailing garbage bytes. Awhile back one of
-    // our tests was failing sporadially on the OSX 64-bit builders (both nopt
+    // our tests was failing sporadically on the OSX 64-bit builders (both nopt
     // and opt) by having rbml generate an out-of-bounds panic when looking at
     // metadata.
     //

src/librustc/middle/infer/doc.rs

@@ -125,7 +125,7 @@
 //! Another option is to keep A and B as distinct variables but set their
 //! bounds in such a way that, whatever happens, we know that A <: B will hold.
 //! This can be achieved by ensuring that A.ub <: B.lb.  In practice there
-//! are two ways to do that, depicted pictorally here:
+//! are two ways to do that, depicted pictorially here:
 //!
 //! ```text
 //!     Before                Option #1            Option #2

src/librustc/middle/infer/error_reporting.rs

@@ -37,7 +37,7 @@
 //!
 //! # Subtype Trace
 //!
-//! Determing whether `T1 <: T2` often involves a number of subtypes and
+//! Determining whether `T1 <: T2` often involves a number of subtypes and
 //! subconstraints along the way. A "TypeTrace" is an extended version
 //! of an origin that traces the types and other values that were being
 //! compared. It is not necessarily comprehensive (in fact, at the time of

src/librustc/middle/infer/higher_ranked/doc.rs

@@ -198,7 +198,7 @@
 //!
 //! So the way we solve this is to add a fourth step that examines the
 //! constraints that refer to skolemized names. Basically, consider a
-//! non-directed verison of the constraint graph. Let `Tainted(x)` be the
+//! non-directed version of the constraint graph. Let `Tainted(x)` be the
 //! set of all things reachable from a skolemized variable `x`.
 //! `Tainted(x)` should not contain any regions that existed before the
 //! step at which the skolemization was performed. So this case here

src/librustc/middle/infer/region_inference/doc.rs

@@ -38,7 +38,7 @@
 //! - ConstrainVarSubVar(R_i, R_j) states that region variable R_i
 //!   must be a subregion of R_j
 //! - ConstrainRegSubVar(R, R_i) states that the concrete region R
-//!   (which must not be a variable) must be a subregion of the varibale R_i
+//!   (which must not be a variable) must be a subregion of the variable R_i
 //! - ConstrainVarSubReg(R_i, R) is the inverse
 //!
 //! # Building up the constraints

src/librustc/middle/infer/region_inference/mod.rs

@@ -106,7 +106,7 @@ pub enum RegionResolutionError<'tcx> {
 
     /// `GenericBoundFailure(p, s, a, bs)
     ///
-    /// The parameter/assocated-type `p` must be known to outlive the lifetime
+    /// The parameter/associated-type `p` must be known to outlive the lifetime
     /// `a`, but it is only known to outlive `bs` (and none of the
     /// regions in `bs` outlive `a`).
     GenericBoundFailure(SubregionOrigin<'tcx>, GenericKind<'tcx>, Region, Vec<Region>),
@@ -337,7 +337,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
     ///
     /// The idea is to always create a snapshot. Skolemized regions
     /// can be created in the context of this snapshot, but once the
-    /// snapshot is commited or rolled back, their numbers will be
+    /// snapshot is committed or rolled back, their numbers will be
     /// recycled, so you must be finished with them. See the extensive
     /// comments in `higher_ranked.rs` to see how it works (in
     /// particular, the subtyping comparison).