Fixing basic typos in Doc Comments

Author: Fourchaux

src/bootstrap/lib.rs

@@ -635,7 +635,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,
@@ -1036,7 +1036,7 @@ impl Build {
 }
 
 impl<'a> Compiler<'a> {
- /// Creates a new complier for the specified stage/host
+ /// Creates a new compiler for the specified stage/host
  fn new(stage: u32, host: &'a str) -> Compiler<'a> {
  Compiler { stage: stage, host: host }
  }

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).
 //!

src/liballoc/allocator.rs

@@ -40,7 +40,7 @@ fn size_align<T>() -> (usize, usize) {
 ///
 /// (Note however that layouts are *not* required to have positive
 /// size, even though many allocators require that all memory
-/// requeusts have positive size. A caller to the `Alloc::alloc`
+/// requests have positive size. A caller to the `Alloc::alloc`
 /// method must either ensure that conditions like this are met, or
 /// use specific allocators with looser requirements.)
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -213,7 +213,7 @@ impl Layout {
  ///
  /// Returns `Some((k, offset))`, where `k` is layout of the concatenated
  /// record and `offset` is the relative location, in bytes, of the
- /// start of the `next` embedded witnin the concatenated record
+ /// start of the `next` embedded within the concatenated record
  /// (assuming that the record itself starts at offset 0).
  ///
  /// On arithmetic overflow, returns `None`.
@@ -266,11 +266,11 @@ 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
- /// start of the `next` embedded witnin the concatenated record
+ /// start of the `next` embedded within the concatenated record
  /// (assuming that the record itself starts at offset 0).
  ///
  /// (The `offset` is always the same as `self.size()`; we use this

src/liballoc/btree/node.rs

@@ -132,7 +132,7 @@ impl<K, V> InternalNode<K, V> {
 
 /// An owned pointer to a node. This basically is either `Box<LeafNode<K, V>>` or
 /// `Box<InternalNode<K, V>>`. However, it contains no information as to which of the two types
-/// of nodes is acutally behind the box, and, partially due to this lack of information, has no
+/// of nodes is actually behind the box, and, partially due to this lack of information, has no
 /// destructor.
 struct BoxedNode<K, V> {
  ptr: Unique<LeafNode<K, V>>
@@ -270,7 +270,7 @@ impl<K, V> Root<K, V> {
 // correct variance.
 /// A reference to a node.
 ///
-/// This type has a number of paramaters that controls how it acts:
+/// This type has a number of parameters that controls how it acts:
 /// - `BorrowType`: This can be `Immut<'a>` or `Mut<'a>` for some `'a` or `Owned`.
 /// When this is `Immut<'a>`, the `NodeRef` acts roughly like `&'a Node`,
 /// when this is `Mut<'a>`, the `NodeRef` acts roughly like `&'a mut Node`,
@@ -775,7 +775,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
  }

src/libcore/iter/mod.rs

@@ -1031,7 +1031,7 @@ unsafe impl<A, B> TrustedLen for Zip<A, B>
 /// Now consider this twist where we add a call to `rev`. This version will
 /// print `('c', 1), ('b', 2), ('a', 3)`. Note that the letters are reversed,
 /// but the values of the counter still go in order. This is because `map()` is
-/// still being called lazilly on each item, but we are popping items off the
+/// still being called lazily on each item, but we are popping items off the
 /// back of the vector now, instead of shifting them from the front.
 ///
 /// ```rust

src/libcore/iter/traits.rs

@@ -362,7 +362,7 @@ pub trait Extend<A> {
 /// In a similar fashion to the [`Iterator`] protocol, once a
 /// `DoubleEndedIterator` returns `None` from a `next_back()`, calling it again
 /// may or may not ever return `Some` again. `next()` and `next_back()` are
-/// interchangable for this purpose.
+/// interchangeable for this purpose.
 ///
 /// [`Iterator`]: trait.Iterator.html
 ///

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.

src/libcore/ops/place.rs

@@ -59,7 +59,7 @@ pub trait Place<Data: ?Sized> {
 /// or `Copy`, since the `make_place` method takes `self` by value.
 #[unstable(feature = "placement_new_protocol", issue = "27779")]
 pub trait Placer<Data: ?Sized> {
- /// `Place` is the intermedate agent guarding the
+ /// `Place` is the intermediate agent guarding the
  /// uninitialized state for `Data`.
  type Place: InPlace<Data>;
 

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);
 /// }
 ///

src/librustc/hir/intravisit.rs

@@ -87,7 +87,7 @@ pub enum NestedVisitorMap<'this, 'tcx: 'this> {
  /// Do not visit nested item-like things, but visit nested things
  /// that are inside of an item-like.
  ///
- /// **This is the most common choice.** A very commmon pattern is
+ /// **This is the most common choice.** A very common pattern is
  /// to use `visit_all_item_likes()` as an outer loop,
  /// and to have the visitor that visits the contents of each item
  /// using this setting.