diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs index cf6ebb48b2c6c..e325fc65f051d 100644 --- a/src/bootstrap/builder.rs +++ b/src/bootstrap/builder.rs @@ -257,7 +257,7 @@ impl<'a> Builder<'a> { Kind::Bench => describe!(check::Crate, check::CrateLibrustc), Kind::Doc => describe!(doc::UnstableBook, doc::UnstableBookGen, doc::TheBook, doc::Standalone, doc::Std, doc::Test, doc::Rustc, doc::ErrorIndex, doc::Nomicon, - doc::Reference, doc::Rustdoc), + doc::Reference, doc::Rustdoc, doc::CargoBook), Kind::Dist => describe!(dist::Docs, dist::Mingw, dist::Rustc, dist::DebuggerScripts, dist::Std, dist::Analysis, dist::Src, dist::PlainSourceTarball, dist::Cargo, dist::Rls, dist::Extended, dist::HashSign), diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs index 5ade2c279e2fb..86f5346bea1fb 100644 --- a/src/bootstrap/doc.rs +++ b/src/bootstrap/doc.rs @@ -240,6 +240,51 @@ impl Step for TheBook { } } +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CargoBook { + target: Interned, +} + +impl Step for CargoBook { + type Output = (); + const DEFAULT: bool = true; + + fn should_run(run: ShouldRun) -> ShouldRun { + let builder = run.builder; + run.path("src/doc/cargo").default_condition(builder.build.config.docs) + } + + fn make_run(run: RunConfig) { + run.builder.ensure(CargoBook { + target: run.target, + }); + } + + /// Create a placeholder for the cargo documentation so that doc.rust-lang.org/cargo will + /// redirect to doc.crates.io. We want to publish doc.rust-lang.org/cargo in the paper + /// version of the book, but we don't want to rush the process of switching cargo's docs + /// over to mdbook and deploying them. When the cargo book is ready, this implementation + /// should build the mdbook instead of this redirect page. + fn run(self, builder: &Builder) { + let build = builder.build; + let out = build.doc_out(self.target); + + let cargo_dir = out.join("cargo"); + t!(fs::create_dir_all(&cargo_dir)); + + let index = cargo_dir.join("index.html"); + let redirect_html = r#" + + + + + "#; + + println!("Creating cargo book redirect page"); + t!(t!(File::create(&index)).write_all(redirect_html.as_bytes())); + } +} + fn invoke_rustdoc(builder: &Builder, compiler: Compiler, target: Interned, markdown: &str) { let build = builder.build; let out = build.doc_out(target); diff --git a/src/bootstrap/lib.rs b/src/bootstrap/lib.rs index 17f8bcdf03da1..b6e0098157633 100644 --- a/src/bootstrap/lib.rs +++ b/src/bootstrap/lib.rs @@ -444,7 +444,7 @@ impl Build { } /// Returns the root output directory for all Cargo output in a given stage, - /// running a particular compiler, wehther or not we're building the + /// running a particular compiler, whether or not we're building the /// standard library, and targeting the specified architecture. fn cargo_out(&self, compiler: Compiler, diff --git a/src/bootstrap/native.rs b/src/bootstrap/native.rs index 59efbd5c4d20d..0a307e72bf61d 100644 --- a/src/bootstrap/native.rs +++ b/src/bootstrap/native.rs @@ -11,7 +11,7 @@ //! Compilation of native dependencies like LLVM. //! //! Native projects like LLVM unfortunately aren't suited just yet for -//! compilation in build scripts that Cargo has. This is because thie +//! compilation in build scripts that Cargo has. This is because the //! compilation takes a *very* long time but also because we don't want to //! compile LLVM 3 times as part of a normal bootstrap (we want it cached). //! diff --git a/src/doc/book b/src/doc/book index 6f1a03dae6bce..d09c9e8144ed3 160000 --- a/src/doc/book +++ b/src/doc/book @@ -1 +1 @@ -Subproject commit 6f1a03dae6bcea44976918186f2d554186b3499c +Subproject commit d09c9e8144ed32170b7596abb145ade8b097acaf diff --git a/src/doc/nomicon b/src/doc/nomicon index f570bcb681771..a4322ccb289a4 160000 --- a/src/doc/nomicon +++ b/src/doc/nomicon @@ -1 +1 @@ -Subproject commit f570bcb681771d691aa4fdb8dfcfad1939844bf5 +Subproject commit a4322ccb289a43cc238d4536982f184a3eec9ba7 diff --git a/src/liballoc/allocator.rs b/src/liballoc/allocator.rs index 2b3df15f71618..fc6585a9f951d 100644 --- a/src/liballoc/allocator.rs +++ b/src/liballoc/allocator.rs @@ -293,7 +293,7 @@ impl Layout { /// Creates a layout describing the record for `self` followed by /// `next` with no additional padding between the two. Since no /// padding is inserted, the alignment of `next` is irrelevant, - /// and is not incoporated *at all* into the resulting layout. + /// and is not incorporated *at all* into the resulting layout. /// /// Returns `(k, offset)`, where `k` is layout of the concatenated /// record and `offset` is the relative location, in bytes, of the @@ -528,7 +528,7 @@ pub unsafe trait Alloc { /// to allocate that block of memory. unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout); - /// Allocator-specific method for signalling an out-of-memory + /// Allocator-specific method for signaling an out-of-memory /// condition. /// /// `oom` aborts the thread or process, optionally performing @@ -539,7 +539,7 @@ pub unsafe trait Alloc { /// unsatisfied allocation request (signaled by an error such as /// `AllocErr::Exhausted`), and wish to abandon computation rather /// than attempt to recover locally. Such clients should pass the - /// signalling error value back into `oom`, where the allocator + /// signaling error value back into `oom`, where the allocator /// may incorporate that error value into its diagnostic report /// before aborting. /// diff --git a/src/liballoc/btree/node.rs b/src/liballoc/btree/node.rs index b057c18fca895..c1618043ce66f 100644 --- a/src/liballoc/btree/node.rs +++ b/src/liballoc/btree/node.rs @@ -763,7 +763,7 @@ impl Clone for Handle { } impl Handle { - /// Retrieves the node that contains the edge of key/value pair this handle pointes to. + /// Retrieves the node that contains the edge of key/value pair this handle points to. pub fn into_node(self) -> Node { self.node } diff --git a/src/liballoc/raw_vec.rs b/src/liballoc/raw_vec.rs index 9a8614895f30c..841f9dc64142e 100644 --- a/src/liballoc/raw_vec.rs +++ b/src/liballoc/raw_vec.rs @@ -544,12 +544,12 @@ impl RawVec { /// Attempts to ensure that the buffer contains at least enough space to hold /// `used_cap + needed_extra_cap` elements. If it doesn't already have /// enough capacity, will reallocate in place enough space plus comfortable slack - /// space to get amortized `O(1)` behaviour. Will limit this behaviour + /// space to get amortized `O(1)` behavior. Will limit this behaviour /// if it would needlessly cause itself to panic. /// /// If `used_cap` exceeds `self.cap()`, this may fail to actually allocate /// the requested space. This is not really unsafe, but the unsafe - /// code *you* write that relies on the behaviour of this function may break. + /// code *you* write that relies on the behavior of this function may break. /// /// Returns true if the reallocation attempt has succeeded, or false otherwise. /// diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 6068f1a79611e..dc0905e297251 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -809,7 +809,7 @@ impl RefCell { /// [`borrow_mut`] method instead if `self` isn't mutable. /// /// Also, please be aware that this method is only for special circumstances and is usually - /// not you want. In case of doubt, use [`borrow_mut`] instead. + /// not what you want. In case of doubt, use [`borrow_mut`] instead. /// /// [`borrow_mut`]: #method.borrow_mut /// diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index 2000ba9146029..a8b84203d6a6c 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -240,7 +240,12 @@ pub trait Hash { /// [`write_u8`]: #method.write_u8 #[stable(feature = "rust1", since = "1.0.0")] pub trait Hasher { - /// Completes a round of hashing, producing the output hash generated. + /// Returns the hash value for the values written so far. + /// + /// Despite its name, the method does not reset the hasher’s internal + /// state. Additional [`write`]s will continue from the current value. + /// If you need to start a fresh hash value, you will have to create + /// a new hasher. /// /// # Examples /// @@ -253,6 +258,8 @@ pub trait Hasher { /// /// println!("Hash is {:x}!", hasher.finish()); /// ``` + /// + /// ['write']: #tymethod.write #[stable(feature = "rust1", since = "1.0.0")] fn finish(&self) -> u64; diff --git a/src/libcore/num/dec2flt/rawfp.rs b/src/libcore/num/dec2flt/rawfp.rs index 2a60292d0232e..12960fed04550 100644 --- a/src/libcore/num/dec2flt/rawfp.rs +++ b/src/libcore/num/dec2flt/rawfp.rs @@ -102,10 +102,10 @@ pub trait RawFloat : Float + Copy + Debug + LowerExp /// The number of bits in the exponent. const EXP_BITS: u8; - /// The number of bits in the singificand, *including* the hidden bit. + /// The number of bits in the significand, *including* the hidden bit. const SIG_BITS: u8; - /// The number of bits in the singificand, *excluding* the hidden bit. + /// The number of bits in the significand, *excluding* the hidden bit. const EXPLICIT_SIG_BITS: u8; /// The maximum legal exponent in fractional representation. @@ -123,7 +123,7 @@ pub trait RawFloat : Float + Copy + Debug + LowerExp /// `MIN_EXP` for integral representation, i.e., with the shift applied. const MIN_EXP_INT: i16; - /// The maximum normalized singificand in integral representation. + /// The maximum normalized significand in integral representation. const MAX_SIG: u64; /// The minimal normalized significand in integral representation. diff --git a/src/libcore/ops/try.rs b/src/libcore/ops/try.rs index 4971e825a6fbe..78326c3e6391a 100644 --- a/src/libcore/ops/try.rs +++ b/src/libcore/ops/try.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -/// A trait for customizing the behaviour of the `?` operator. +/// A trait for customizing the behavior of the `?` operator. /// /// A type implementing `Try` is one that has a canonical way to view it /// in terms of a success/failure dichotomy. This trait allows both diff --git a/src/libcore/sync/atomic.rs b/src/libcore/sync/atomic.rs index d647a94a1efde..510e01db0e965 100644 --- a/src/libcore/sync/atomic.rs +++ b/src/libcore/sync/atomic.rs @@ -1632,7 +1632,7 @@ unsafe fn atomic_xor(dst: *mut T, val: T, order: Ordering) -> T { /// /// pub fn lock(&self) { /// while !self.flag.compare_and_swap(false, true, Ordering::Relaxed) {} -/// // This fence syncronizes-with store in `unlock`. +/// // This fence synchronizes-with store in `unlock`. /// fence(Ordering::Acquire); /// } /// diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index d66fba18f475c..4ee0c3d92bd2c 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -11,7 +11,7 @@ //! Generate files suitable for use with [Graphviz](http://www.graphviz.org/) //! //! The `render` function generates output (e.g. an `output.dot` file) for -//! use with [Graphviz](http://www.graphviz.org/) by walking a labelled +//! use with [Graphviz](http://www.graphviz.org/) by walking a labeled //! graph. (Graphviz can then automatically lay out the nodes and edges //! of the graph, and also optionally render the graph as an image or //! other [output formats]( @@ -150,7 +150,7 @@ //! //! The output from this example renders four nodes that make up the //! Hasse-diagram for the subsets of the set `{x, y}`. Each edge is -//! labelled with the ⊆ character (specified using the HTML character +//! labeled with the ⊆ character (specified using the HTML character //! entity `&sube`). //! //! ```rust @@ -789,7 +789,7 @@ mod tests { } struct LabelledGraph { - /// The name for this graph. Used for labelling generated `digraph`. + /// The name for this graph. Used for labeling generated `digraph`. name: &'static str, /// Each node is an index into `node_labels`; these labels are diff --git a/src/librand/distributions/gamma.rs b/src/librand/distributions/gamma.rs index 188e71f3fa948..e796197ab5bf2 100644 --- a/src/librand/distributions/gamma.rs +++ b/src/librand/distributions/gamma.rs @@ -254,7 +254,7 @@ impl IndependentSample for ChiSquared { /// The Fisher F distribution `F(m, n)`. /// -/// This distribution is equivalent to the ratio of two normalised +/// This distribution is equivalent to the ratio of two normalized /// chi-squared distributions, that is, `F(m,n) = (χ²(m)/m) / /// (χ²(n)/n)`. pub struct FisherF { diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs index 2baa07e370e17..96ce0905e384d 100644 --- a/src/librand/isaac.rs +++ b/src/librand/isaac.rs @@ -76,7 +76,7 @@ impl IsaacRng { rng } - /// Initialises `self`. If `use_rsl` is true, then use the current value + /// Initializes `self`. If `use_rsl` is true, then use the current value /// of `rsl` as a seed, otherwise construct one algorithmically (not /// randomly). fn init(&mut self, use_rsl: bool) { @@ -367,7 +367,7 @@ impl Isaac64Rng { rng } - /// Initialises `self`. If `use_rsl` is true, then use the current value + /// Initializes `self`. If `use_rsl` is true, then use the current value /// of `rsl` as a seed, otherwise construct one algorithmically (not /// randomly). fn init(&mut self, use_rsl: bool) { diff --git a/src/librand/lib.rs b/src/librand/lib.rs index a1b6ddcb331a8..a3c4f6a4b1db1 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -180,7 +180,7 @@ pub trait Rng: Sized { /// This method does *not* have a requirement to bear any fixed /// relationship to the other methods, for example, it does *not* /// have to result in the same output as progressively filling - /// `dest` with `self.gen::()`, and any such behaviour should + /// `dest` with `self.gen::()`, and any such behavior should /// not be relied upon. /// /// This method should guarantee that `dest` is entirely filled diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs index 804fe9dc63c53..2821b7a8232df 100644 --- a/src/librand/reseeding.rs +++ b/src/librand/reseeding.rs @@ -24,7 +24,7 @@ pub struct ReseedingRng { rng: R, generation_threshold: usize, bytes_generated: usize, - /// Controls the behaviour when reseeding the RNG. + /// Controls the behavior when reseeding the RNG. pub reseeder: Rsdr, } diff --git a/src/librustc/diagnostics.rs b/src/librustc/diagnostics.rs index 522c1531c5938..34d31028385cf 100644 --- a/src/librustc/diagnostics.rs +++ b/src/librustc/diagnostics.rs @@ -362,6 +362,10 @@ Here are some simple examples of where you'll run into this error: struct Foo { x: &bool } // error struct Foo<'a> { x: &'a bool } // correct +struct Bar { x: Foo } + ^^^ expected lifetime parameter +struct Bar<'a> { x: Foo<'a> } // correct + enum Bar { A(u8), B(&bool), } // error enum Bar<'a> { A(u8), B(&'a bool), } // correct diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index ed4e28cc9ebf2..8cd229a2adf63 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -731,7 +731,7 @@ impl<'hir> Map<'hir> { /// Returns the nearest enclosing scope. A scope is an item or block. /// FIXME it is not clear to me that all items qualify as scopes - statics - /// and associated types probably shouldn't, for example. Behaviour in this + /// and associated types probably shouldn't, for example. Behavior in this /// regard should be expected to be highly unstable. pub fn get_enclosing_scope(&self, id: NodeId) -> Option { match self.walk_parent_nodes(id, |node| match *node { diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs index b5390da7e852d..d608d09d05498 100644 --- a/src/librustc/infer/error_reporting/mod.rs +++ b/src/librustc/infer/error_reporting/mod.rs @@ -24,7 +24,7 @@ //! a span, but also more information so that we can generate a meaningful //! error message. //! -//! Having a catalogue of all the different reasons an error can arise is +//! Having a catalog of all the different reasons an error can arise is //! also useful for other reasons, like cross-referencing FAQs etc, though //! we are not really taking advantage of this yet. //! diff --git a/src/librustc/infer/resolve.rs b/src/librustc/infer/resolve.rs index 6a1f8f1d06927..639a330dc6e67 100644 --- a/src/librustc/infer/resolve.rs +++ b/src/librustc/infer/resolve.rs @@ -46,7 +46,7 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for OpportunisticTypeResolver<'a, 'g } /// The opportunistic type and region resolver is similar to the -/// opportunistic type resolver, but also opportunistly resolves +/// opportunistic type resolver, but also opportunistically resolves /// regions. It is useful for canonicalization. pub struct OpportunisticTypeAndRegionResolver<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { infcx: &'a InferCtxt<'a, 'gcx, 'tcx>, diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 40d78d0138bb2..92b159a55f49a 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -101,7 +101,7 @@ pub struct FutureIncompatibleInfo { pub reference: &'static str // e.g., a URL for an issue/PR/RFC or error code } -/// The targed of the `by_name` map, which accounts for renaming/deprecation. +/// The target of the `by_name` map, which accounts for renaming/deprecation. enum TargetLint { /// A direct lint target Id(LintId), diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 9133a5e777db2..45a3080ed91ff 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -72,7 +72,7 @@ use mir::transform::MirSource; /// (M1.): Misc extent of the whole `let a = ...;` statement. /// (M2.): Misc extent of the `f()` expression. /// (M3.): Misc extent of the `f().g(..)` expression. -/// (M4.): Misc extent of the block labelled `'b:`. +/// (M4.): Misc extent of the block labeled `'b:`. /// (M5.): Misc extent of the `let x = d();` statement /// (D6.): DestructionScope for temporaries created during M5. /// (R7.): Remainder extent for block `'b:`, stmt 0 (let x = ...). diff --git a/src/librustc/mir/traversal.rs b/src/librustc/mir/traversal.rs index 5aab46b3cefb4..74c3408c4c2f6 100644 --- a/src/librustc/mir/traversal.rs +++ b/src/librustc/mir/traversal.rs @@ -216,7 +216,7 @@ impl<'a, 'tcx> Iterator for Postorder<'a, 'tcx> { /// /// Reverse postorder is the reverse order of a postorder traversal. /// This is different to a preorder traversal and represents a natural -/// linearisation of control-flow. +/// linearization of control-flow. /// /// ```text /// diff --git a/src/librustc/traits/fulfill.rs b/src/librustc/traits/fulfill.rs index 4f1eb6169209b..78e47693caaf1 100644 --- a/src/librustc/traits/fulfill.rs +++ b/src/librustc/traits/fulfill.rs @@ -37,7 +37,7 @@ impl<'tcx> ForestObligation for PendingPredicateObligation<'tcx> { /// consists of a list of obligations that must be (eventually) /// satisfied. The job is to track which are satisfied, which yielded /// errors, and which are still pending. At any point, users can call -/// `select_where_possible`, and the fulfilment context will try to do +/// `select_where_possible`, and the fulfillment context will try to do /// selection, retaining only those obligations that remain /// ambiguous. This may be helpful in pushing type inference /// along. Once all type inference constraints have been generated, the diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 7d34b908edf44..da1039c5de176 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -851,7 +851,7 @@ pub struct GlobalCtxt<'tcx> { /// A vector of every trait accessible in the whole crate /// (i.e. including those from subcrates). This is used only for - /// error reporting, and so is lazily initialised and generally + /// error reporting, and so is lazily initialized and generally /// shouldn't taint the common path (hence the RefCell). pub all_traits: RefCell>>, } diff --git a/src/librustc/ty/inhabitedness/def_id_forest.rs b/src/librustc/ty/inhabitedness/def_id_forest.rs index 896682e2370e2..3629709e6a48d 100644 --- a/src/librustc/ty/inhabitedness/def_id_forest.rs +++ b/src/librustc/ty/inhabitedness/def_id_forest.rs @@ -26,7 +26,7 @@ pub struct DefIdForest { /// The minimal set of DefIds required to represent the whole set. /// If A and B are DefIds in the DefIdForest, and A is a descendant /// of B, then only B will be in root_ids. - /// We use a SmallVec here because (for its use for cacheing inhabitedness) + /// We use a SmallVec here because (for its use for caching inhabitedness) /// its rare that this will contain even two ids. root_ids: SmallVec<[DefId; 1]>, } diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index 389c581ebe314..8d6b7b7ac9fdd 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -739,7 +739,7 @@ pub type Region<'tcx> = &'tcx RegionKind; /// /// The process of doing that is called "skolemization". The bound regions /// are replaced by skolemized markers, which don't satisfy any relation -/// not explicity provided. +/// not explicitly provided. /// /// There are 2 kinds of skolemized regions in rustc: `ReFree` and /// `ReSkolemized`. When checking an item's body, `ReFree` is supposed diff --git a/src/librustc_data_structures/accumulate_vec.rs b/src/librustc_data_structures/accumulate_vec.rs index c03c2890ba34c..52306de74cb8b 100644 --- a/src/librustc_data_structures/accumulate_vec.rs +++ b/src/librustc_data_structures/accumulate_vec.rs @@ -13,7 +13,7 @@ //! Space for up to N elements is provided on the stack. If more elements are collected, Vec is //! used to store the values on the heap. //! -//! The N above is determined by Array's implementor, by way of an associatated constant. +//! The N above is determined by Array's implementor, by way of an associated constant. use std::ops::{Deref, DerefMut}; use std::iter::{self, IntoIterator, FromIterator}; diff --git a/src/librustc_data_structures/ivar.rs b/src/librustc_data_structures/ivar.rs index f842f4a41a118..de44509ef2fd8 100644 --- a/src/librustc_data_structures/ivar.rs +++ b/src/librustc_data_structures/ivar.rs @@ -14,7 +14,7 @@ use std::cell::Cell; /// A write-once variable. When constructed, it is empty, and /// can only be set once. /// -/// Ivars ensure that data that can only be initialised once. A full +/// Ivars ensure that data that can only be initialized once. A full /// implementation is used for concurrency and blocks on a read of an /// unfulfilled value. This implementation is more minimal and panics /// if you attempt to read the value before it has been set. It is also diff --git a/src/librustc_data_structures/small_vec.rs b/src/librustc_data_structures/small_vec.rs index 4e2b378602102..74738e61b4467 100644 --- a/src/librustc_data_structures/small_vec.rs +++ b/src/librustc_data_structures/small_vec.rs @@ -14,7 +14,7 @@ //! used to store the values on the heap. SmallVec is similar to AccumulateVec, but adds //! the ability to push elements. //! -//! The N above is determined by Array's implementor, by way of an associatated constant. +//! The N above is determined by Array's implementor, by way of an associated constant. use std::ops::{Deref, DerefMut}; use std::iter::{IntoIterator, FromIterator}; diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 0c729b5a3fc87..c98f9c3d4660a 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -306,7 +306,7 @@ pub fn source_name(input: &Input) -> String { } } -/// CompileController is used to customise compilation, it allows compilation to +/// CompileController is used to customize compilation, it allows compilation to /// be stopped and/or to call arbitrary code at various points in compilation. /// It also allows for various flags to be set to influence what information gets /// collected during compilation. diff --git a/src/librustc_errors/diagnostic.rs b/src/librustc_errors/diagnostic.rs index 6c52eabd66d12..5a7016e72395a 100644 --- a/src/librustc_errors/diagnostic.rs +++ b/src/librustc_errors/diagnostic.rs @@ -93,9 +93,9 @@ impl Diagnostic { } /// Cancel the diagnostic (a structured diagnostic must either be emitted or - /// cancelled or it will panic when dropped). + /// canceled or it will panic when dropped). /// BEWARE: if this DiagnosticBuilder is an error, then creating it will - /// bump the error count on the Handler and cancelling it won't undo that. + /// bump the error count on the Handler and canceling it won't undo that. /// If you want to decrement the error count you should use `Handler::cancel`. pub fn cancel(&mut self) { self.level = Level::Cancelled; diff --git a/src/librustc_errors/diagnostic_builder.rs b/src/librustc_errors/diagnostic_builder.rs index ee0bd9498982c..73e09fd8fa993 100644 --- a/src/librustc_errors/diagnostic_builder.rs +++ b/src/librustc_errors/diagnostic_builder.rs @@ -198,7 +198,7 @@ impl<'a> Debug for DiagnosticBuilder<'a> { } } -/// Destructor bomb - a `DiagnosticBuilder` must be either emitted or cancelled +/// Destructor bomb - a `DiagnosticBuilder` must be either emitted or canceled /// or we emit a bug. impl<'a> Drop for DiagnosticBuilder<'a> { fn drop(&mut self) { diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs index 22b6a888f257a..3b1414ef83a69 100644 --- a/src/librustc_errors/emitter.rs +++ b/src/librustc_errors/emitter.rs @@ -822,7 +822,7 @@ impl EmitterWriter { .map(|_| " ") .collect::(); - /// Return wether `style`, or the override if present and the style is `NoStyle`. + /// Return whether `style`, or the override if present and the style is `NoStyle`. fn style_or_override(style: Style, override_style: Option