fix more typos found by codespell.

RELEASES.md

@@ -29,7 +29,7 @@ Libraries
 - [Copied `AsciiExt` methods onto `char`][46077]
 - [Remove `T: Sized` requirement on `ptr::is_null()`][46094]
 - [impl `From<RecvError>` for `{TryRecvError, RecvTimeoutError}`][45506]
-- [Optimised `f32::{min, max}` to generate more efficent x86 assembly][47080]
+- [Optimised `f32::{min, max}` to generate more efficient x86 assembly][47080]
 - [`[u8]::contains` now uses memchr which provides a 3x speed improvement][46713]
 
 Stabilized APIs

config.toml.example

@@ -151,8 +151,8 @@
 # default.
 #extended = false
 
-# Installs choosen set of extended tools if enables. By default builds all.
-# If choosen tool failed to build the installation fails.
+# Installs chosen set of extended tools if enables. By default builds all.
+# If chosen tool failed to build the installation fails.
 #tools = ["cargo", "rls", "rustfmt", "analysis", "src"]
 
 # Verbosity level: 0 == not verbose, 1 == verbose, 2 == very verbose

src/bootstrap/test.rs

@@ -935,7 +935,7 @@ impl Step for Compiletest {
             }
         }
         if suite == "run-make" && !build.config.llvm_enabled {
-            println!("Ignoring run-make test suite as they generally dont work without LLVM");
+            println!("Ignoring run-make test suite as they generally don't work without LLVM");
             return;
         }
 

src/librustc/diagnostics.rs

@@ -1891,7 +1891,7 @@ is a function pointer, which is not zero-sized.
 This pattern should be rewritten. There are a few possible ways to do this:
 
 - change the original fn declaration to match the expected signature,
-  and do the cast in the fn body (the prefered option)
+  and do the cast in the fn body (the preferred option)
 - cast the fn item fo a fn pointer before calling transmute, as shown here:
 
     ```

src/librustc/hir/mod.rs

@@ -543,7 +543,7 @@ impl Generics {
 }
 
 /// Synthetic Type Parameters are converted to an other form during lowering, this allows
-/// to track the original form they had. Usefull for error messages.
+/// to track the original form they had. Useful for error messages.
 #[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub enum SyntheticTyParamKind {
     ImplTrait

src/librustc/infer/error_reporting/mod.rs

@@ -734,7 +734,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 }
             }
 
-            // When finding T != &T, hightlight only the borrow
+            // When finding T != &T, highlight only the borrow
             (&ty::TyRef(r1, ref tnm1), _) if equals(&tnm1.ty, &t2) => {
                 let mut values = (DiagnosticStyledString::new(), DiagnosticStyledString::new());
                 push_ty_ref(&r1, tnm1, &mut values.0);
@@ -946,7 +946,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                         let type_param = generics.type_param(param, self.tcx);
                         let hir = &self.tcx.hir;
                         hir.as_local_node_id(type_param.def_id).map(|id| {
-                            // Get the `hir::TyParam` to verify wether it already has any bounds.
+                            // Get the `hir::TyParam` to verify whether it already has any bounds.
                             // We do this to avoid suggesting code that ends up as `T: 'a'b`,
                             // instead we suggest `T: 'a + 'b` in that case.
                             let has_lifetimes = if let hir_map::NodeTyParam(ref p) = hir.get(id) {

src/librustc/infer/outlives/obligations.rs

@@ -106,7 +106,7 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
     /// done (or else an assert will fire).
     ///
     /// See the `region_obligations` field of `InferCtxt` for some
-    /// comments about how this funtion fits into the overall expected
+    /// comments about how this function fits into the overall expected
     /// flow of the the inferencer. The key point is that it is
     /// invoked after all type-inference variables have been bound --
     /// towards the end of regionck. This also ensures that the

src/librustc/infer/region_constraints/README.md

@@ -19,7 +19,7 @@ The constraints are always of one of three possible forms:
   a subregion of Rj
 - `ConstrainRegSubVar(R, Ri)` states that the concrete region R (which
   must not be a variable) must be a subregion of the variable Ri
-- `ConstrainVarSubReg(Ri, R)` states the variable Ri shoudl be less
+- `ConstrainVarSubReg(Ri, R)` states the variable Ri should be less
   than the concrete region R. This is kind of deprecated and ought to
   be replaced with a verify (they essentially play the same role).
 

src/librustc/middle/region.rs

@@ -886,7 +886,7 @@ fn resolve_block<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'a, 'tcx>, blk:
     //
     // Each of the statements within the block is a terminating
     // scope, and thus a temporary (e.g. the result of calling
-    // `bar()` in the initalizer expression for `let inner = ...;`)
+    // `bar()` in the initializer expression for `let inner = ...;`)
     // will be cleaned up immediately after its corresponding
     // statement (i.e. `let inner = ...;`) executes.
     //

src/librustc/mir/interpret/mod.rs

@@ -56,7 +56,7 @@ pub struct GlobalId<'tcx> {
 ////////////////////////////////////////////////////////////////////////////////
 
 pub trait PointerArithmetic: layout::HasDataLayout {
-    // These are not supposed to be overriden.
+    // These are not supposed to be overridden.
 
     //// Trunace the given value to the pointer size; also return whether there was an overflow
     fn truncate_to_ptr(self, val: u128) -> (u64, bool) {

src/librustc/mir/mod.rs

@@ -1950,7 +1950,7 @@ pub struct GeneratorLayout<'tcx> {
 /// ```
 ///
 /// here, there is one unique free region (`'a`) but it appears
-/// twice. We would "renumber" each occurence to a unique vid, as follows:
+/// twice. We would "renumber" each occurrence to a unique vid, as follows:
 ///
 /// ```text
 /// ClosureSubsts = [

src/librustc/traits/coherence.rs

@@ -277,7 +277,7 @@ pub fn orphan_check<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
 ///     is bad, because the only local type with `T` as a subtree is
 ///     `LocalType<T>`, and `Vec<->` is between it and the type parameter.
 ///     - similarly, `FundamentalPair<LocalType<T>, T>` is bad, because
-///     the second occurence of `T` is not a subtree of *any* local type.
+///     the second occurrence of `T` is not a subtree of *any* local type.
 ///     - however, `LocalType<Vec<T>>` is OK, because `T` is a subtree of
 ///     `LocalType<Vec<T>>`, which is local and has no types between it and
 ///     the type parameter.

src/librustc/traits/mod.rs

@@ -621,7 +621,7 @@ pub fn fully_normalize<'a, 'gcx, 'tcx, T>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
     // FIXME (@jroesch) ISSUE 26721
     // I'm not sure if this is a bug or not, needs further investigation.
     // It appears that by reusing the fulfillment_cx here we incur more
-    // obligations and later trip an asssertion on regionck.rs line 337.
+    // obligations and later trip an assertion on regionck.rs line 337.
     //
     // The two possibilities I see is:
     //      - normalization is not actually fully happening and we

src/librustc/ty/layout.rs

@@ -2059,7 +2059,7 @@ impl<'a, 'tcx> LayoutOf<Ty<'tcx>> for LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
         // can however trigger recursive invocations of `layout_of`.
         // Therefore, we execute it *after* the main query has
         // completed, to avoid problems around recursive structures
-        // and the like. (Admitedly, I wasn't able to reproduce a problem
+        // and the like. (Admittedly, I wasn't able to reproduce a problem
         // here, but it seems like the right thing to do. -nmatsakis)
         self.record_layout_for_printing(layout);
 
@@ -2085,7 +2085,7 @@ impl<'a, 'tcx> LayoutOf<Ty<'tcx>> for LayoutCx<'tcx, ty::maps::TyCtxtAt<'a, 'tcx
         // can however trigger recursive invocations of `layout_of`.
         // Therefore, we execute it *after* the main query has
         // completed, to avoid problems around recursive structures
-        // and the like. (Admitedly, I wasn't able to reproduce a problem
+        // and the like. (Admittedly, I wasn't able to reproduce a problem
         // here, but it seems like the right thing to do. -nmatsakis)
         let cx = LayoutCx {
             tcx: *self.tcx,

src/librustc_apfloat/tests/ieee.rs

@@ -2201,12 +2201,12 @@ fn is_finite_non_zero() {
     assert!(!Single::ZERO.is_finite_non_zero());
     assert!(!(-Single::ZERO).is_finite_non_zero());
 
-    // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
+    // Test +/- qNaN. +/- don't mean anything with qNaN but paranoia can't hurt in
     // this instance.
     assert!(!Single::NAN.is_finite_non_zero());
     assert!(!(-Single::NAN).is_finite_non_zero());
 
-    // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
+    // Test +/- sNaN. +/- don't mean anything with sNaN but paranoia can't hurt in
     // this instance.
     assert!(!Single::snan(None).is_finite_non_zero());
     assert!(!(-Single::snan(None)).is_finite_non_zero());

src/librustc_borrowck/borrowck/mod.rs

@@ -1111,7 +1111,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
 
     /// Given a type, if it is an immutable reference, return a suggestion to make it mutable
     fn suggest_mut_for_immutable(&self, pty: &hir::Ty, is_implicit_self: bool) -> Option<String> {
-        // Check wether the argument is an immutable reference
+        // Check whether the argument is an immutable reference
         debug!("suggest_mut_for_immutable({:?}, {:?})", pty, is_implicit_self);
         if let hir::TyRptr(lifetime, hir::MutTy {
             mutbl: hir::Mutability::MutImmutable,

src/librustc_const_eval/_match.rs

@@ -607,7 +607,7 @@ pub fn is_useful<'p, 'a: 'p, 'tcx: 'a>(cx: &mut MatchCheckCtxt<'a, 'tcx>,
         // be able to observe whether the types of the struct's fields are
         // inhabited.
         //
-        // If the field is truely inaccessible, then all the patterns
+        // If the field is truly inaccessible, then all the patterns
         // matching against it must be wildcard patterns, so its type
         // does not matter.
         //

src/librustc_data_structures/indexed_vec.rs

@@ -204,7 +204,7 @@ macro_rules! newtype_index {
                           $($tokens)*);
     );
 
-    // The case where no derives are added, but encodable is overriden. Don't
+    // The case where no derives are added, but encodable is overridden. Don't
     // derive serialization traits
     (@pub          [$($pub:tt)*]
      @type         [$type:ident]

src/librustc_mir/borrow_check/mod.rs

@@ -117,7 +117,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(
             for move_error in move_errors {
                 let (span, kind): (Span, IllegalMoveOriginKind) = match move_error {
                     MoveError::UnionMove { .. } => {
-                        unimplemented!("dont know how to report union move errors yet.")
+                        unimplemented!("don't know how to report union move errors yet.")
                     }
                     MoveError::IllegalMove {
                         cannot_move_out_of: o,
@@ -1424,7 +1424,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
     /// tracked in the MoveData.
     ///
     /// An Err result includes a tag indicated why the search failed.
-    /// Currenly this can only occur if the place is built off of a
+    /// Currently this can only occur if the place is built off of a
     /// static variable, as we do not track those in the MoveData.
     fn move_path_closest_to(
         &mut self,
@@ -1439,7 +1439,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         }
         match *last_prefix {
             Place::Local(_) => panic!("should have move path for every Local"),
-            Place::Projection(_) => panic!("PrefixSet::All meant dont stop for Projection"),
+            Place::Projection(_) => panic!("PrefixSet::All meant don't stop for Projection"),
             Place::Static(_) => return Err(NoMovePathFound::ReachedStatic),
         }
     }
@@ -1484,7 +1484,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
                         { }
 
                         ProjectionElem::Subslice { .. } => {
-                            panic!("we dont allow assignments to subslices, context: {:?}",
+                            panic!("we don't allow assignments to subslices, context: {:?}",
                                    context);
                         }
 

src/librustc_mir/borrow_check/nll/mod.rs

@@ -278,7 +278,7 @@ fn for_each_region_constraint(
 
 /// Right now, we piggy back on the `ReVar` to store our NLL inference
 /// regions. These are indexed with `RegionVid`. This method will
-/// assert that the region is a `ReVar` and extract its interal index.
+/// assert that the region is a `ReVar` and extract its internal index.
 /// This is reasonable because in our MIR we replace all universal regions
 /// with inference variables.
 pub trait ToRegionVid {

src/librustc_mir/borrow_check/nll/region_infer/mod.rs

@@ -964,7 +964,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                     debug!("check_universal_region: fr_minus={:?}", fr_minus);
 
                     // Grow `shorter_fr` until we find a non-local
-                    // regon. (We always will.)  We'll call that
+                    // region. (We always will.)  We'll call that
                     // `shorter_fr+` -- it's ever so slightly larger than
                     // `fr`.
                     let shorter_fr_plus = self.universal_regions.non_local_upper_bound(shorter_fr);

src/librustc_mir/borrow_check/nll/region_infer/values.rs

@@ -150,7 +150,7 @@ pub(super) enum RegionElement {
     /// A point in the control-flow graph.
     Location(Location),
 
-    /// An in-scope, universally quantified region (e.g., a liftime parameter).
+    /// An in-scope, universally quantified region (e.g., a lifetime parameter).
     UniversalRegion(RegionVid),
 }
 

src/librustc_mir/build/matches/mod.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Code related to match expresions. These are sufficiently complex
+//! Code related to match expressions. These are sufficiently complex
 //! to warrant their own module and submodules. :) This main module
 //! includes the high-level algorithm, the submodules contain the
 //! details.

src/librustc_mir/dataflow/impls/borrows.rs

@@ -80,14 +80,14 @@ pub struct Borrows<'a, 'gcx: 'tcx, 'tcx: 'a> {
 /// tracking (phased) borrows. It computes where a borrow is reserved;
 /// i.e. where it can reach in the control flow starting from its
 /// initial `assigned = &'rgn borrowed` statement, and ending
-/// whereever `'rgn` itself ends.
+/// wherever `'rgn` itself ends.
 pub(crate) struct Reservations<'a, 'gcx: 'tcx, 'tcx: 'a>(pub(crate) Borrows<'a, 'gcx, 'tcx>);
 
 /// The `ActiveBorrows` analysis is the second of the two flow
 /// analyses tracking (phased) borrows. It computes where any given
 /// borrow `&assigned = &'rgn borrowed` is *active*, which starts at
 /// the first use of `assigned` after the reservation has started, and
-/// ends whereever `'rgn` itself ends.
+/// ends wherever `'rgn` itself ends.
 pub(crate) struct ActiveBorrows<'a, 'gcx: 'tcx, 'tcx: 'a>(pub(crate) Borrows<'a, 'gcx, 'tcx>);
 
 impl<'a, 'gcx, 'tcx> Reservations<'a, 'gcx, 'tcx> {

src/librustc_mir/diagnostics.rs

@@ -365,7 +365,7 @@ with `#[derive(Clone)]`.
 Some types have no ownership semantics at all and are trivial to duplicate. An
 example is `i32` and the other number types. We don't have to call `.clone()` to
 clone them, because they are marked `Copy` in addition to `Clone`.  Implicit
-cloning is more convienient in this case. We can mark our own types `Copy` if
+cloning is more convenient in this case. We can mark our own types `Copy` if
 all their members also are marked `Copy`.
 
 In the example below, we implement a `Point` type. Because it only stores two

src/librustc_mir/interpret/eval_context.rs

@@ -84,7 +84,7 @@ pub struct Frame<'tcx> {
     /// return).
     pub block: mir::BasicBlock,
 
-    /// The index of the currently evaluated statment.
+    /// The index of the currently evaluated statement.
     pub stmt: usize,
 }
 

src/librustc_mir/monomorphize/item.rs

@@ -68,7 +68,7 @@ pub enum InstantiationMode {
         /// however, our local copy may conflict with other crates also
         /// inlining the same function.
         ///
-        /// This flag indicates that this situation is occuring, and informs
+        /// This flag indicates that this situation is occurring, and informs
         /// symbol name calculation that some extra mangling is needed to
         /// avoid conflicts. Note that this may eventually go away entirely if
         /// ThinLTO enables us to *always* have a globally shared instance of a

src/librustc_privacy/lib.rs

@@ -781,7 +781,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypePrivacyVisitor<'a, 'tcx> {
     // Additionally, until better reachability analysis for macros 2.0 is available,
     // we prohibit access to private statics from other crates, this allows to give
     // more code internal visibility at link time. (Access to private functions
-    // is already prohibited by type privacy for funciton types.)
+    // is already prohibited by type privacy for function types.)
     fn visit_qpath(&mut self, qpath: &'tcx hir::QPath, id: ast::NodeId, span: Span) {
         let def = match *qpath {
             hir::QPath::Resolved(_, ref path) => match path.def {

src/librustc_resolve/check_unused.rs

@@ -17,7 +17,7 @@
 // `use` directives.
 //
 // Unused trait imports can't be checked until the method resolution. We save
-// candidates here, and do the acutal check in librustc_typeck/check_unused.rs.
+// candidates here, and do the actual check in librustc_typeck/check_unused.rs.
 
 use std::ops::{Deref, DerefMut};
 

src/librustc_resolve/lib.rs

@@ -1440,7 +1440,7 @@ impl<'a> Resolver<'a> {
     /// Rustdoc uses this to resolve things in a recoverable way. ResolutionError<'a>
     /// isn't something that can be returned because it can't be made to live that long,
     /// and also it's a private type. Fortunately rustdoc doesn't need to know the error,
-    /// just that an error occured.
+    /// just that an error occurred.
     pub fn resolve_str_path_error(&mut self, span: Span, path_str: &str, is_value: bool)
         -> Result<hir::Path, ()> {
         use std::iter;

src/librustc_resolve/resolve_imports.rs

@@ -186,7 +186,7 @@ impl<'a> Resolver<'a> {
         }
 
         let check_usable = |this: &mut Self, binding: &'a NameBinding<'a>| {
-            // `extern crate` are always usable for backwards compatability, see issue #37020.
+            // `extern crate` are always usable for backwards compatibility, see issue #37020.
             let usable = this.is_accessible(binding.vis) || binding.is_extern_crate();
             if usable { Ok(binding) } else { Err(Determined) }
         };

src/librustc_trans/back/lto.rs

@@ -84,7 +84,7 @@ impl LtoModuleTranslation {
         }
     }
 
-    /// A "guage" of how costly it is to optimize this module, used to sort
+    /// A "gauge" of how costly it is to optimize this module, used to sort
     /// biggest modules first.
     pub fn cost(&self) -> u64 {
         match *self {
@@ -726,7 +726,7 @@ impl ThinModule {
         // which was basically a resurgence of #45511 after LLVM's bug 35212 was
         // fixed.
         //
-        // This function below is a huge hack around tihs problem. The function
+        // This function below is a huge hack around this problem. The function
         // below is defined in `PassWrapper.cpp` and will basically "merge"
         // all `DICompileUnit` instances in a module. Basically it'll take all
         // the objects, rewrite all pointers of `DISubprogram` to point to the

src/librustc_trans/builder.rs

@@ -1240,7 +1240,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// on), and `ptr` is nonzero-sized, then extracts the size of `ptr`
     /// and the intrinsic for `lt` and passes them to `emit`, which is in
     /// charge of generating code to call the passed intrinsic on whatever
-    /// block of generated code is targetted for the intrinsic.
+    /// block of generated code is targeted for the intrinsic.
     ///
     /// If LLVM lifetime intrinsic support is disabled (i.e.  optimizations
     /// off) or `ptr` is zero-sized, then no-op (does not call `emit`).

src/librustc_trans/mir/rvalue.rs

@@ -844,7 +844,7 @@ fn cast_float_to_int(bx: &Builder,
     // They are exactly equal to int_ty::{MIN,MAX} if float_ty has enough significand bits.
     // Otherwise, int_ty::MAX must be rounded towards zero, as it is one less than a power of two.
     // int_ty::MIN, however, is either zero or a negative power of two and is thus exactly
-    // representable. Note that this only works if float_ty's exponent range is sufficently large.
+    // representable. Note that this only works if float_ty's exponent range is sufficiently large.
     // f16 or 256 bit integers would break this property. Right now the smallest float type is f32
     // with exponents ranging up to 127, which is barely enough for i128::MIN = -2^127.
     // On the other hand, f_max works even if int_ty::MAX is greater than float_ty::MAX. Because

src/librustc_trans_utils/trans_crate.rs

@@ -151,7 +151,7 @@ impl MetadataLoader for NoLlvmMetadataLoader {
             }
         }
 
-        Err("Couldnt find metadata section".to_string())
+        Err("Couldn't find metadata section".to_string())
     }
 
     fn get_dylib_metadata(

src/libstd/io/buffered.rs

@@ -293,7 +293,7 @@ impl<R: Seek> Seek for BufReader<R> {
     /// where `n` minus the internal buffer length overflows an `i64`, two
     /// seeks will be performed instead of one. If the second seek returns
     /// `Err`, the underlying reader will be left at the same position it would
-    /// have if you seeked to `SeekFrom::Current(0)`.
+    /// have if you called `seek` with `SeekFrom::Current(0)`.
     ///
     /// [`seek_relative`]: #method.seek_relative
     fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {

src/libstd/sync/rwlock.rs

@@ -24,8 +24,8 @@ use sys_common::rwlock as sys;
 /// typically allows for read-only access (shared access).
 ///
 /// In comparison, a [`Mutex`] does not distinguish between readers or writers
-/// that aquire the lock, therefore blocking any threads waiting for the lock to
-/// become available. An `RwLock` will allow any number of readers to aquire the
+/// that acquire the lock, therefore blocking any threads waiting for the lock to
+/// become available. An `RwLock` will allow any number of readers to acquire the
 /// lock as long as a writer is not holding the lock.
 ///
 /// The priority policy of the lock is dependent on the underlying operating

src/libstd/sys_common/backtrace.rs

@@ -136,7 +136,7 @@ pub fn __rust_begin_short_backtrace<F, T>(f: F) -> T
     f()
 }
 
-/// Controls how the backtrace should be formated.
+/// Controls how the backtrace should be formatted.
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum PrintFormat {
     /// Show all the frames with absolute path for files.

src/libstd/sys_common/poison.rs

@@ -98,7 +98,7 @@ pub struct PoisonError<T> {
 }
 
 /// An enumeration of possible errors associated with a [`TryLockResult`] which
-/// can occur while trying to aquire a lock, from the [`try_lock`] method on a
+/// can occur while trying to acquire a lock, from the [`try_lock`] method on a
 /// [`Mutex`] or the [`try_read`] and [`try_write`] methods on an [`RwLock`].
 ///
 /// [`Mutex`]: struct.Mutex.html

src/libsyntax/ast.rs

@@ -918,7 +918,7 @@ pub struct Expr {
 }
 
 impl Expr {
-    /// Wether this expression would be valid somewhere that expects a value, for example, an `if`
+    /// Whether this expression would be valid somewhere that expects a value, for example, an `if`
     /// condition.
     pub fn returns(&self) -> bool {
         if let ExprKind::Block(ref block) = self.node {

src/libsyntax/config.rs

@@ -114,7 +114,7 @@ impl<'a> StripUnconfigured<'a> {
         }
     }
 
-    // Determine if a node with the given attributes should be included in this configuation.
+    // Determine if a node with the given attributes should be included in this configuration.
     pub fn in_cfg(&mut self, attrs: &[ast::Attribute]) -> bool {
         attrs.iter().all(|attr| {
             // When not compiling with --test we should not compile the #[test] functions

src/libsyntax/parse/parser.rs

@@ -3912,7 +3912,7 @@ impl<'a> Parser<'a> {
                                           "use `=` if you meant to assign",
                                           "=".to_string());
                 err.emit();
-                // As this was parsed successfuly, continue as if the code has been fixed for the
+                // As this was parsed successfully, continue as if the code has been fixed for the
                 // rest of the file. It will still fail due to the emitted error, but we avoid
                 // extra noise.
                 init
@@ -6571,7 +6571,7 @@ impl<'a> Parser<'a> {
             return Ok(Some(macro_def));
         }
 
-        // Verify wether we have encountered a struct or method definition where the user forgot to
+        // Verify whether we have encountered a struct or method definition where the user forgot to
         // add the `struct` or `fn` keyword after writing `pub`: `pub S {}`
         if visibility == Visibility::Public &&
             self.check_ident() &&

src/test/compile-fail/coerce-to-bang.rs

@@ -14,7 +14,7 @@
 fn foo(x: usize, y: !, z: usize) { }
 
 fn call_foo_a() {
-    // FIXME(#40800) -- accepted beacuse divergence happens **before**
+    // FIXME(#40800) -- accepted because divergence happens **before**
     // the coercion to `!`, but within same expression. Not clear that
     // these are the rules we want.
     foo(return, 22, 44);

src/test/compile-fail/directory_ownership/macro_expanded_mod_helper/foo/bar.rs

@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-test not a test, auxillary
+// ignore-test not a test, auxiliary

src/test/compile-fail/directory_ownership/macro_expanded_mod_helper/foo/mod.rs

@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-test not a test, auxillary
+// ignore-test not a test, auxiliary
 
 mod_decl!(bar);

src/test/compile-fail/hr-subtype.rs

@@ -84,7 +84,7 @@ check! { free_inv_x_vs_free_inv_y: (fn(Inv<'x>),
                                     fn(Inv<'y>)) }
 
 // Somewhat surprisingly, a fn taking two distinct bound lifetimes and
-// a fn taking one bound lifetime can be interchangable, but only if
+// a fn taking one bound lifetime can be interchangeable, but only if
 // we are co- or contra-variant with respect to both lifetimes.
 //
 // The reason is:
@@ -100,7 +100,7 @@ check! { bound_contra_a_contra_b_ret_co_a: (for<'a,'b> fn(Contra<'a>, Contra<'b>
 check! { bound_co_a_co_b_ret_contra_a: (for<'a,'b> fn(Co<'a>, Co<'b>) -> Contra<'a>,
                                         for<'a>    fn(Co<'a>, Co<'a>) -> Contra<'a>) }
 
-// If we make those lifetimes invariant, then the two types are not interchangable.
+// If we make those lifetimes invariant, then the two types are not interchangeable.
 check! { bound_inv_a_b_vs_bound_inv_a: (for<'a,'b> fn(Inv<'a>, Inv<'b>),
                                         for<'a>    fn(Inv<'a>, Inv<'a>)) }
 check! { bound_a_b_ret_a_vs_bound_a_ret_a: (for<'a,'b> fn(&'a u32, &'b u32) -> &'a u32,

src/test/compile-fail/issue-20616-1.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // We need all these 9 issue-20616-N.rs files
-// becase we can only catch one parsing error at a time
+// because we can only catch one parsing error at a time
 
 
 

src/test/compile-fail/issue-20616-2.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // We need all these 9 issue-20616-N.rs files
-// becase we can only catch one parsing error at a time
+// because we can only catch one parsing error at a time
 
 
 

src/test/compile-fail/issue-20616-3.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // We need all these 9 issue-20616-N.rs files
-// becase we can only catch one parsing error at a time
+// because we can only catch one parsing error at a time
 
 
 

src/test/compile-fail/issue-20616-4.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // We need all these 9 issue-20616-N.rs files
-// becase we can only catch one parsing error at a time
+// because we can only catch one parsing error at a time
 
 
 

src/test/compile-fail/issue-20616-5.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // We need all these 9 issue-20616-N.rs files
-// becase we can only catch one parsing error at a time
+// because we can only catch one parsing error at a time
 
 
 

src/test/compile-fail/issue-20616-6.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // We need all these 9 issue-20616-N.rs files
-// becase we can only catch one parsing error at a time
+// because we can only catch one parsing error at a time
 
 
 

src/test/compile-fail/issue-20616-7.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // We need all these 9 issue-20616-N.rs files
-// becase we can only catch one parsing error at a time
+// because we can only catch one parsing error at a time
 
 
 

src/test/compile-fail/issue-20616-8.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // We need all these 9 issue-20616-N.rs files
-// becase we can only catch one parsing error at a time
+// because we can only catch one parsing error at a time
 
 
 

src/test/compile-fail/issue-20616-9.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // We need all these 9 issue-20616-N.rs files
-// becase we can only catch one parsing error at a time
+// because we can only catch one parsing error at a time
 
 
 

src/test/compile-fail/no_crate_type.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// regresion test for issue 11256
+// regression test for issue 11256
 #![crate_type]  //~ ERROR `crate_type` requires a value
 
 fn main() {

src/test/mir-opt/README.md

@@ -26,7 +26,7 @@ other non-matched lines before and after, but not between $expected_lines,
 should you want to skip lines, you must include an elision comment, of the form
 (as a regex) `//\s*...\s*`. The lines will be skipped lazily, that is, if there
 are two identical lines in the output that match the line after the elision
-comment, the first one wil be matched.
+comment, the first one will be matched.
 
 Examples:
 

src/test/pretty/stmt_expr_attributes.rs

@@ -255,7 +255,7 @@ fn _11() {
     while true { let _ = #[attr] break ; }
     || #[attr] return;
     let _ = #[attr] expr_mac!();
-    /* FIXME: pp bug, loosing delimiter styles
+    /* FIXME: pp bug, losing delimiter styles
     let _ = #[attr] expr_mac![];
     let _ = #[attr] expr_mac!{};
     */

src/test/run-make/hotplug_codegen_backend/Makefile

@@ -6,4 +6,4 @@ all:
 		-o $(TMPDIR)/the_backend.dylib
 	$(RUSTC) some_crate.rs --crate-name some_crate --crate-type bin -o $(TMPDIR)/some_crate \
 		-Z codegen-backend=$(TMPDIR)/the_backend.dylib -Z unstable-options
-	grep -x "This has been \"compiled\" succesfully." $(TMPDIR)/some_crate
+	grep -x "This has been \"compiled\" successfully." $(TMPDIR)/some_crate

src/test/run-make/hotplug_codegen_backend/the_backend.rs

@@ -69,7 +69,7 @@ impl TransCrate for TheBackend {
             let output_name =
                 out_filename(sess, crate_type, &outputs, &*crate_name.as_str());
             let mut out_file = ::std::fs::File::create(output_name).unwrap();
-            write!(out_file, "This has been \"compiled\" succesfully.").unwrap();
+            write!(out_file, "This has been \"compiled\" successfully.").unwrap();
         }
         Ok(())
     }

src/test/run-pass-fulldeps/proc-macro/auxiliary/derive-reexport.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-test not a test, auxillary
+// ignore-test not a test, auxiliary
 
 #![feature(macro_reexport)]
 

src/test/run-pass/issue-29746.rs

@@ -17,7 +17,7 @@ macro_rules! zip {
     };
 
     // Intermediate steps to build the zipped expression, the match pattern, and
-    //  and the output tuple of the closure, using macro hygene to repeatedly
+    //  and the output tuple of the closure, using macro hygiene to repeatedly
     //  introduce new variables named 'x'.
     ([$a:expr, $($rest:expr),*], $zip:expr, $pat:pat, [$($flat:expr),*]) => {
         zip!([$($rest),*], $zip.zip($a), ($pat,x), [$($flat),*, x])

src/test/run-pass/issue-32008.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // Tests that binary operators allow subtyping on both the LHS and RHS,
-// and as such do not introduce unnecesarily strict lifetime constraints.
+// and as such do not introduce unnecessarily strict lifetime constraints.
 
 use std::ops::Add;
 

src/test/run-pass/rfc1857-drop-order.rs

@@ -67,7 +67,7 @@ fn test_drop_tuple() {
     panic::catch_unwind(|| {
         (PushOnDrop::new(2, cloned.clone()),
          PushOnDrop::new(1, cloned.clone()),
-         panic!("this panic is catched :D"));
+         panic!("this panic is caught :D"));
     }).err().unwrap();
     assert_eq!(*dropped_fields.borrow(), &[1, 2]);
 }
@@ -99,7 +99,7 @@ fn test_drop_struct() {
         TestStruct {
             x: PushOnDrop::new(2, cloned.clone()),
             y: PushOnDrop::new(1, cloned.clone()),
-            z: panic!("this panic is catched :D")
+            z: panic!("this panic is caught :D")
         };
     }).err().unwrap();
     assert_eq!(*dropped_fields.borrow(), &[1, 2]);
@@ -111,7 +111,7 @@ fn test_drop_struct() {
         TestStruct {
             y: PushOnDrop::new(2, cloned.clone()),
             x: PushOnDrop::new(1, cloned.clone()),
-            z: panic!("this panic is catched :D")
+            z: panic!("this panic is caught :D")
         };
     }).err().unwrap();
     assert_eq!(*dropped_fields.borrow(), &[1, 2]);
@@ -122,7 +122,7 @@ fn test_drop_struct() {
     panic::catch_unwind(|| {
         TestTupleStruct(PushOnDrop::new(2, cloned.clone()),
                         PushOnDrop::new(1, cloned.clone()),
-                        panic!("this panic is catched :D"));
+                        panic!("this panic is caught :D"));
     }).err().unwrap();
     assert_eq!(*dropped_fields.borrow(), &[1, 2]);
 }
@@ -154,7 +154,7 @@ fn test_drop_enum() {
         TestEnum::Struct {
             x: PushOnDrop::new(2, cloned.clone()),
             y: PushOnDrop::new(1, cloned.clone()),
-            z: panic!("this panic is catched :D")
+            z: panic!("this panic is caught :D")
         };
     }).err().unwrap();
     assert_eq!(*dropped_fields.borrow(), &[1, 2]);
@@ -166,7 +166,7 @@ fn test_drop_enum() {
         TestEnum::Struct {
             y: PushOnDrop::new(2, cloned.clone()),
             x: PushOnDrop::new(1, cloned.clone()),
-            z: panic!("this panic is catched :D")
+            z: panic!("this panic is caught :D")
         };
     }).err().unwrap();
     assert_eq!(*dropped_fields.borrow(), &[1, 2]);
@@ -177,7 +177,7 @@ fn test_drop_enum() {
     panic::catch_unwind(|| {
         TestEnum::Tuple(PushOnDrop::new(2, cloned.clone()),
                         PushOnDrop::new(1, cloned.clone()),
-                        panic!("this panic is catched :D"));
+                        panic!("this panic is caught :D"));
     }).err().unwrap();
     assert_eq!(*dropped_fields.borrow(), &[1, 2]);
 }
@@ -207,7 +207,7 @@ fn test_drop_list() {
         vec![
             PushOnDrop::new(2, cloned.clone()),
             PushOnDrop::new(1, cloned.clone()),
-            panic!("this panic is catched :D")
+            panic!("this panic is caught :D")
         ];
     }).err().unwrap();
     assert_eq!(*dropped_fields.borrow(), &[1, 2]);
@@ -219,7 +219,7 @@ fn test_drop_list() {
         [
             PushOnDrop::new(2, cloned.clone()),
             PushOnDrop::new(1, cloned.clone()),
-            panic!("this panic is catched :D")
+            panic!("this panic is caught :D")
         ];
     }).err().unwrap();
     assert_eq!(*dropped_fields.borrow(), &[1, 2]);

src/test/run-pass/simd-target-feature-mixup.rs

@@ -30,7 +30,7 @@ fn main() {
 
         // We don't actually know if our computer has the requisite target features
         // for the test below. Testing for that will get added to libstd later so
-        // for now just asume sigill means this is a machine that can't run this test.
+        // for now just assume sigill means this is a machine that can't run this test.
         if is_sigill(status) {
             println!("sigill with {}, assuming spurious", level);
             continue

src/test/rustdoc/impl-parts-crosscrate.rs

@@ -17,7 +17,7 @@ extern crate rustdoc_impl_parts_crosscrate;
 
 pub struct Bar<T> { t: T }
 
-// The output file is html embeded in javascript, so the html tags
+// The output file is html embedded in javascript, so the html tags
 // aren't stripped by the processing script and we can't check for the
 // full impl string.  Instead, just make sure something from each part
 // is mentioned.

src/test/ui/explain.stdout

@@ -45,7 +45,7 @@ is a function pointer, which is not zero-sized.
 This pattern should be rewritten. There are a few possible ways to do this:
 
 - change the original fn declaration to match the expected signature,
-  and do the cast in the fn body (the prefered option)
+  and do the cast in the fn body (the preferred option)
 - cast the fn item fo a fn pointer before calling transmute, as shown here:
 
     ```

src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.rs

@@ -509,7 +509,7 @@ mod reexport_test_harness_main {
     //~^ WARN unused attribute
 }
 
-// Cannnot feed "2700" to `#[macro_escape]` without signaling an error.
+// Cannot feed "2700" to `#[macro_escape]` without signaling an error.
 #[macro_escape]
 //~^ WARN macro_escape is a deprecated synonym for macro_use
 mod macro_escape {

src/test/ui/lifetime-errors/liveness-assign-imm-local-notes.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // FIXME: Change to UI Test
-// Check notes are placed on an assignment that can actually preceed the current assigmnent
+// Check notes are placed on an assignment that can actually precede the current assigmnent
 // Don't emmit a first assignment for assignment in a loop.
 
 // compile-flags: -Zborrowck=compare