diff --git a/RELEASES.md b/RELEASES.md
index 7a9d256be28..64e2145e0f3 100644
--- a/RELEASES.md
+++ b/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
diff --git a/config.toml.example b/config.toml.example
index f153562a538..8d1fa3eec5c 100644
--- a/config.toml.example
+++ b/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
diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs
index 64ede4f4ecc..7b485662760 100644
--- a/src/bootstrap/test.rs
+++ b/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;
}
diff --git a/src/librustc/diagnostics.rs b/src/librustc/diagnostics.rs
index 4c256556191..287516474d4 100644
--- a/src/librustc/diagnostics.rs
+++ b/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:
```
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
index 2854b9da147..bc03f7ead81 100644
--- a/src/librustc/hir/mod.rs
+++ b/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
diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs
index 03fc40b2e39..700d06acf11 100644
--- a/src/librustc/infer/error_reporting/mod.rs
+++ b/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) {
diff --git a/src/librustc/infer/outlives/obligations.rs b/src/librustc/infer/outlives/obligations.rs
index eda2e1f7b4e..36e657f78b4 100644
--- a/src/librustc/infer/outlives/obligations.rs
+++ b/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
diff --git a/src/librustc/infer/region_constraints/README.md b/src/librustc/infer/region_constraints/README.md
index 67ad08c7530..95f9c8c8353 100644
--- a/src/librustc/infer/region_constraints/README.md
+++ b/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).
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
index e5619f469e7..3ce4ab04777 100644
--- a/src/librustc/middle/region.rs
+++ b/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.
//
diff --git a/src/librustc/mir/interpret/mod.rs b/src/librustc/mir/interpret/mod.rs
index 8ffea62f6be..a80695ec9b9 100644
--- a/src/librustc/mir/interpret/mod.rs
+++ b/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) {
diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs
index 439be667861..b88dea871ce 100644
--- a/src/librustc/mir/mod.rs
+++ b/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 = [
diff --git a/src/librustc/traits/coherence.rs b/src/librustc/traits/coherence.rs
index 9de18612d81..7311b47974a 100644
--- a/src/librustc/traits/coherence.rs
+++ b/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.
diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs
index 80819a86b7c..41cc8ca601a 100644
--- a/src/librustc/traits/mod.rs
+++ b/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
diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs
index 63b91ff1101..c3cd65230bd 100644
--- a/src/librustc/ty/layout.rs
+++ b/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,
diff --git a/src/librustc_apfloat/tests/ieee.rs b/src/librustc_apfloat/tests/ieee.rs
index aff2076e038..ff46ee79c31 100644
--- a/src/librustc_apfloat/tests/ieee.rs
+++ b/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());
diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs
index 738c0d82ee1..58818d0ce80 100644
--- a/src/librustc_borrowck/borrowck/mod.rs
+++ b/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,
diff --git a/src/librustc_const_eval/_match.rs b/src/librustc_const_eval/_match.rs
index a7c382eba50..e30f5cb4f12 100644
--- a/src/librustc_const_eval/_match.rs
+++ b/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.
//
diff --git a/src/librustc_data_structures/indexed_vec.rs b/src/librustc_data_structures/indexed_vec.rs
index 753f12f400b..b11ca107af7 100644
--- a/src/librustc_data_structures/indexed_vec.rs
+++ b/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]
diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs
index 650f99828ae..c6ed971f767 100644
--- a/src/librustc_mir/borrow_check/mod.rs
+++ b/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);
}
diff --git a/src/librustc_mir/borrow_check/nll/mod.rs b/src/librustc_mir/borrow_check/nll/mod.rs
index 66ca74b0139..07e5091da9c 100644
--- a/src/librustc_mir/borrow_check/nll/mod.rs
+++ b/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 {
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs
index 9a338947f47..33c012dfad8 100644
--- a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs
+++ b/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);
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/values.rs b/src/librustc_mir/borrow_check/nll/region_infer/values.rs
index b2b2ca1182d..45236bbc4aa 100644
--- a/src/librustc_mir/borrow_check/nll/region_infer/values.rs
+++ b/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),
}
diff --git a/src/librustc_mir/build/matches/mod.rs b/src/librustc_mir/build/matches/mod.rs
index 8053a0a6948..58ce572ae8d 100644
--- a/src/librustc_mir/build/matches/mod.rs
+++ b/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.
diff --git a/src/librustc_mir/dataflow/impls/borrows.rs b/src/librustc_mir/dataflow/impls/borrows.rs
index e798cc93cb0..8ab4035cf4a 100644
--- a/src/librustc_mir/dataflow/impls/borrows.rs
+++ b/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> {
diff --git a/src/librustc_mir/diagnostics.rs b/src/librustc_mir/diagnostics.rs
index 619c0dc847e..3491faf9cda 100644
--- a/src/librustc_mir/diagnostics.rs
+++ b/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
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
index 52b87282180..3578164feb7 100644
--- a/src/librustc_mir/interpret/eval_context.rs
+++ b/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,
}
diff --git a/src/librustc_mir/monomorphize/item.rs b/src/librustc_mir/monomorphize/item.rs
index 86a4dd4a31f..a5078187a57 100644
--- a/src/librustc_mir/monomorphize/item.rs
+++ b/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
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
index b46882f054d..6ae04760953 100644
--- a/src/librustc_privacy/lib.rs
+++ b/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 {
diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs
index 5a321053b7a..a757ac92df5 100644
--- a/src/librustc_resolve/check_unused.rs
+++ b/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};
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 2da4bfedd3a..d8e03552a6a 100644
--- a/src/librustc_resolve/lib.rs
+++ b/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;
diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs
index a8070c553bd..438ab3a3513 100644
--- a/src/librustc_resolve/resolve_imports.rs
+++ b/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) }
};
diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs
index a3327038019..ab354a30d41 100644
--- a/src/librustc_trans/back/lto.rs
+++ b/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
diff --git a/src/librustc_trans/builder.rs b/src/librustc_trans/builder.rs
index 5ab8d03b8c7..d4e05a18e3a 100644
--- a/src/librustc_trans/builder.rs
+++ b/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`).
diff --git a/src/librustc_trans/mir/rvalue.rs b/src/librustc_trans/mir/rvalue.rs
index 2e876ec118d..34ac44cec02 100644
--- a/src/librustc_trans/mir/rvalue.rs
+++ b/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
diff --git a/src/librustc_trans_utils/trans_crate.rs b/src/librustc_trans_utils/trans_crate.rs
index e14abdff339..9943a9bd398 100644
--- a/src/librustc_trans_utils/trans_crate.rs
+++ b/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(
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 4e7db5f0826..9250c1c437b 100644
--- a/src/libstd/io/buffered.rs
+++ b/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> {
diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs
index 2edf02efc47..f7fdedc0d21 100644
--- a/src/libstd/sync/rwlock.rs
+++ b/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
diff --git a/src/libstd/sys_common/backtrace.rs b/src/libstd/sys_common/backtrace.rs
index a364a0392b3..1955f3ec9a2 100644
--- a/src/libstd/sys_common/backtrace.rs
+++ b/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.
diff --git a/src/libstd/sys_common/poison.rs b/src/libstd/sys_common/poison.rs
index 934ac3edbf1..e74c40ae04b 100644
--- a/src/libstd/sys_common/poison.rs
+++ b/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
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index c7ab6158256..8c1e5cf7586 100644
--- a/src/libsyntax/ast.rs
+++ b/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 {
diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs
index fc82357455b..aa360ed1bf5 100644
--- a/src/libsyntax/config.rs
+++ b/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
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index ac582627f88..7915109ce3a 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/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() &&
diff --git a/src/test/compile-fail/coerce-to-bang.rs b/src/test/compile-fail/coerce-to-bang.rs
index 2cf568777d4..b804bb2981b 100644
--- a/src/test/compile-fail/coerce-to-bang.rs
+++ b/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);
diff --git a/src/test/compile-fail/directory_ownership/macro_expanded_mod_helper/foo/bar.rs b/src/test/compile-fail/directory_ownership/macro_expanded_mod_helper/foo/bar.rs
index 9177dcba0d7..4ef92981314 100644
--- a/src/test/compile-fail/directory_ownership/macro_expanded_mod_helper/foo/bar.rs
+++ b/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
diff --git a/src/test/compile-fail/directory_ownership/macro_expanded_mod_helper/foo/mod.rs b/src/test/compile-fail/directory_ownership/macro_expanded_mod_helper/foo/mod.rs
index e29c985b983..41a8c288e7c 100644
--- a/src/test/compile-fail/directory_ownership/macro_expanded_mod_helper/foo/mod.rs
+++ b/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);
diff --git a/src/test/compile-fail/hr-subtype.rs b/src/test/compile-fail/hr-subtype.rs
index c88d74d53ce..86df2382732 100644
--- a/src/test/compile-fail/hr-subtype.rs
+++ b/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,
diff --git a/src/test/compile-fail/issue-20616-1.rs b/src/test/compile-fail/issue-20616-1.rs
index a1949df661a..3e29383d62c 100644
--- a/src/test/compile-fail/issue-20616-1.rs
+++ b/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
diff --git a/src/test/compile-fail/issue-20616-2.rs b/src/test/compile-fail/issue-20616-2.rs
index 87b836d6872..1ec7a74559a 100644
--- a/src/test/compile-fail/issue-20616-2.rs
+++ b/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
diff --git a/src/test/compile-fail/issue-20616-3.rs b/src/test/compile-fail/issue-20616-3.rs
index e5ed46d2cb3..885fd246547 100644
--- a/src/test/compile-fail/issue-20616-3.rs
+++ b/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
diff --git a/src/test/compile-fail/issue-20616-4.rs b/src/test/compile-fail/issue-20616-4.rs
index 9b731289e13..0dbe92fc1bc 100644
--- a/src/test/compile-fail/issue-20616-4.rs
+++ b/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
diff --git a/src/test/compile-fail/issue-20616-5.rs b/src/test/compile-fail/issue-20616-5.rs
index 5e3b024da9a..794e5178f4b 100644
--- a/src/test/compile-fail/issue-20616-5.rs
+++ b/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
diff --git a/src/test/compile-fail/issue-20616-6.rs b/src/test/compile-fail/issue-20616-6.rs
index b6ee26f9f62..fe91751a4a0 100644
--- a/src/test/compile-fail/issue-20616-6.rs
+++ b/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
diff --git a/src/test/compile-fail/issue-20616-7.rs b/src/test/compile-fail/issue-20616-7.rs
index fef3dd4e31d..184ad027102 100644
--- a/src/test/compile-fail/issue-20616-7.rs
+++ b/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
diff --git a/src/test/compile-fail/issue-20616-8.rs b/src/test/compile-fail/issue-20616-8.rs
index b7bef47c4f4..5cdec33e94b 100644
--- a/src/test/compile-fail/issue-20616-8.rs
+++ b/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
diff --git a/src/test/compile-fail/issue-20616-9.rs b/src/test/compile-fail/issue-20616-9.rs
index 5c16d24cef8..7995addb692 100644
--- a/src/test/compile-fail/issue-20616-9.rs
+++ b/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
diff --git a/src/test/compile-fail/no_crate_type.rs b/src/test/compile-fail/no_crate_type.rs
index bef909917d2..b2cc5cae697 100644
--- a/src/test/compile-fail/no_crate_type.rs
+++ b/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() {
diff --git a/src/test/mir-opt/README.md b/src/test/mir-opt/README.md
index b00b35aa29f..ad4932b9fb9 100644
--- a/src/test/mir-opt/README.md
+++ b/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:
diff --git a/src/test/pretty/stmt_expr_attributes.rs b/src/test/pretty/stmt_expr_attributes.rs
index 1c443020d2e..17e6119f968 100644
--- a/src/test/pretty/stmt_expr_attributes.rs
+++ b/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!{};
*/
diff --git a/src/test/run-make/hotplug_codegen_backend/Makefile b/src/test/run-make/hotplug_codegen_backend/Makefile
index 9a216d1d81f..2ddf3aa5439 100644
--- a/src/test/run-make/hotplug_codegen_backend/Makefile
+++ b/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
diff --git a/src/test/run-make/hotplug_codegen_backend/the_backend.rs b/src/test/run-make/hotplug_codegen_backend/the_backend.rs
index 5972149590c..9e87268e699 100644
--- a/src/test/run-make/hotplug_codegen_backend/the_backend.rs
+++ b/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(())
}
diff --git a/src/test/run-pass-fulldeps/proc-macro/auxiliary/derive-reexport.rs b/src/test/run-pass-fulldeps/proc-macro/auxiliary/derive-reexport.rs
index 24865ea2709..cfaf913216a 100644
--- a/src/test/run-pass-fulldeps/proc-macro/auxiliary/derive-reexport.rs
+++ b/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)]
diff --git a/src/test/run-pass/issue-29746.rs b/src/test/run-pass/issue-29746.rs
index 61c601ac6a9..d4463fed1a6 100644
--- a/src/test/run-pass/issue-29746.rs
+++ b/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])
diff --git a/src/test/run-pass/issue-32008.rs b/src/test/run-pass/issue-32008.rs
index cb489acf1d9..95890d2e1b4 100644
--- a/src/test/run-pass/issue-32008.rs
+++ b/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;
diff --git a/src/test/run-pass/rfc1857-drop-order.rs b/src/test/run-pass/rfc1857-drop-order.rs
index b2e5ff62eb8..94b2a586ddf 100644
--- a/src/test/run-pass/rfc1857-drop-order.rs
+++ b/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]);
diff --git a/src/test/run-pass/simd-target-feature-mixup.rs b/src/test/run-pass/simd-target-feature-mixup.rs
index 2c9ef59709d..3c54921ac6e 100644
--- a/src/test/run-pass/simd-target-feature-mixup.rs
+++ b/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
diff --git a/src/test/rustdoc/impl-parts-crosscrate.rs b/src/test/rustdoc/impl-parts-crosscrate.rs
index 5fa2e03e0a8..1d055ccbead 100644
--- a/src/test/rustdoc/impl-parts-crosscrate.rs
+++ b/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.
diff --git a/src/test/ui/explain.stdout b/src/test/ui/explain.stdout
index 0bbbd95320a..411cdfb335b 100644
--- a/src/test/ui/explain.stdout
+++ b/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:
```
diff --git a/src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.rs b/src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.rs
index 029949b2604..21950402c8c 100644
--- a/src/test/ui/feature-gate/issue-43106-gating-of-builtin-attrs.rs
+++ b/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 {
diff --git a/src/test/ui/lifetime-errors/liveness-assign-imm-local-notes.rs b/src/test/ui/lifetime-errors/liveness-assign-imm-local-notes.rs
index d4ef87cdd76..20a2cbfd3aa 100644
--- a/src/test/ui/lifetime-errors/liveness-assign-imm-local-notes.rs
+++ b/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