diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 38ed511c4589a..9b4f879e61ea4 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -185,7 +185,7 @@ impl Drop for Arc { // deletion of the data. Because it is marked `Release`, the // decreasing of the reference count synchronizes with this `Acquire` // fence. This means that use of the data happens before decreasing - // the refernce count, which happens before this fence, which + // the reference count, which happens before this fence, which // happens before the deletion of the data. // // As explained in the [Boost documentation][1], diff --git a/src/libgreen/stack.rs b/src/libgreen/stack.rs index c4885edb7d3a7..5faa9cfe6f6a2 100644 --- a/src/libgreen/stack.rs +++ b/src/libgreen/stack.rs @@ -124,7 +124,7 @@ impl Drop for Stack { } pub struct StackPool { - // Ideally this would be some datastructure that preserved ordering on + // Ideally this would be some data structure that preserved ordering on // Stack.min_size. stacks: Vec, } diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index ba102a85c1bcb..17349f41b98f7 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -288,7 +288,7 @@ pub fn mod_enabled(level: u32, module: &str) -> bool { unsafe { INIT.doit(init); } // It's possible for many threads are in this function, only one of them - // will peform the global initialization, but all of them will need to check + // will perform the global initialization, but all of them will need to check // again to whether they should really be here or not. Hence, despite this // check being expanded manually in the logging macro, this function checks // the log level again. diff --git a/src/libnative/io/net.rs b/src/libnative/io/net.rs index dfc2c55cde7cb..f052826d30386 100644 --- a/src/libnative/io/net.rs +++ b/src/libnative/io/net.rs @@ -877,7 +877,7 @@ pub fn write(fd: sock_t, } // Also as with read(), we use MSG_DONTWAIT to guard ourselves - // against unforseen circumstances. + // against unforeseen circumstances. let _guard = lock(); let ptr = buf.slice_from(written).as_ptr(); let len = buf.len() - written; diff --git a/src/libnative/io/pipe_win32.rs b/src/libnative/io/pipe_win32.rs index da713e3f2a931..e5e8cdeffd7e4 100644 --- a/src/libnative/io/pipe_win32.rs +++ b/src/libnative/io/pipe_win32.rs @@ -376,7 +376,7 @@ impl rtio::RtioPipe for UnixStream { if ret != 0 { return Ok(bytes_read as uint) } // If our errno doesn't say that the I/O is pending, then we hit some - // legitimate error and reeturn immediately. + // legitimate error and return immediately. if os::errno() != libc::ERROR_IO_PENDING as uint { return Err(super::last_error()) } diff --git a/src/librlibc/lib.rs b/src/librlibc/lib.rs index c85e0099ab832..4423ab62f0dcf 100644 --- a/src/librlibc/lib.rs +++ b/src/librlibc/lib.rs @@ -31,7 +31,7 @@ #![no_std] #![experimental] -// This library is definining the builtin functions, so it would be a shame for +// This library defines the builtin functions, so it would be a shame for // LLVM to optimize these function calls to themselves! #![no_builtins] diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index 17f29639601dd..a190d9309cc8d 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -119,7 +119,7 @@ pub mod write { // get all hardware potential via VFP3 (hardware floating point) // and NEON (SIMD) instructions supported by LLVM. // Note that without those flags various linking errors might - // arise as some of intrinsicts are converted into function calls + // arise as some of intrinsics are converted into function calls // and nobody provides implementations those functions fn target_feature<'a>(sess: &'a Session) -> &'a str { match sess.targ_cfg.os { diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 30296cb318617..fda12c50284f9 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -989,7 +989,7 @@ impl UnnecessaryParens { _ => {} } - /// Expressions that syntatically contain an "exterior" struct + /// Expressions that syntactically contain an "exterior" struct /// literal i.e. not surrounded by any parens or other /// delimiters, e.g. `X { y: 1 }`, `X { y: 1 }.method()`, `foo /// == X { y: 1 }` and `X { y: 1 } == foo` all do, but `(X { diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index e1a2a5741fbe1..54cca082e0de8 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -383,7 +383,7 @@ impl<'t,TYPER:Typer> MemCategorizationContext<'t,TYPER> { Some(adjustment) => { match *adjustment { ty::AutoObject(..) => { - // Implicity cast a concrete object to trait object. + // Implicitly cast a concrete object to trait object. // Result is an rvalue. let expr_ty = if_ok!(self.expr_ty_adjusted(expr)); Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty)) diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 414aac47cdcc0..76e962a3bc4da 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -1267,7 +1267,7 @@ impl<'a> Visitor<()> for VisiblePrivateTypesVisitor<'a> { // error messages without (too many) false positives // (i.e. we could just return here to not check them at // all, or some worse estimation of whether an impl is - // publically visible. + // publicly visible. ast::ItemImpl(ref g, ref trait_ref, self_, ref methods) => { // `impl [... for] Private` is never visible. let self_contains_private; diff --git a/src/librustc/middle/save/mod.rs b/src/librustc/middle/save/mod.rs index 2b2f3b8fb0b5f..e46e6541ffceb 100644 --- a/src/librustc/middle/save/mod.rs +++ b/src/librustc/middle/save/mod.rs @@ -484,7 +484,7 @@ impl <'l> DxrVisitor<'l> { { let qualname = self.analysis.ty_cx.map.path_to_str(item.id); - // If the variable is immutable, save the initialising expresion. + // If the variable is immutable, save the initialising expression. let value = match mt { ast::MutMutable => String::from_str(""), ast::MutImmutable => self.span.snippet(expr.span), @@ -845,7 +845,7 @@ impl <'l> DxrVisitor<'l> { let decl_id = ty::trait_method_of_method(&self.analysis.ty_cx, def_id); // This incantation is required if the method referenced is a trait's - // defailt implementation. + // default implementation. let def_id = ty::method(&self.analysis.ty_cx, def_id).provided_source .unwrap_or(def_id); (Some(def_id), decl_id) @@ -1402,7 +1402,7 @@ pub fn process_crate(sess: &Session, info!("Writing output to {}", disp); } - // Create ouput file. + // Create output file. let mut out_name = cratename.clone(); out_name.push_str(".csv"); root_path.push(out_name); diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs index f106ce18a4adb..44afc04d3f0ef 100644 --- a/src/librustc/middle/typeck/infer/unify.rs +++ b/src/librustc/middle/typeck/infer/unify.rs @@ -93,7 +93,7 @@ pub struct UnificationTable { /** * At any time, users may snapshot a unification table. The changes - * made during the snapshot may either be *commited* or *rolled back*. + * made during the snapshot may either be *committed* or *rolled back*. */ pub struct Snapshot { // Ensure that this snapshot is keyed to the table type. @@ -152,7 +152,7 @@ impl> UnificationTable { /** * Starts a new snapshot. Each snapshot must be either - * rolled back or commited in a "LIFO" (stack) order. + * rolled back or committed in a "LIFO" (stack) order. */ pub fn snapshot(&mut self) -> Snapshot { let length = self.undo_log.len(); @@ -188,12 +188,12 @@ impl> UnificationTable { match self.undo_log.pop().unwrap() { OpenSnapshot => { // This indicates a failure to obey the stack discipline. - tcx.sess.bug("Cannot rollback an uncommited snapshot"); + tcx.sess.bug("Cannot rollback an uncommitted snapshot"); } CommittedSnapshot => { // This occurs when there are nested snapshots and - // the inner is commited but outer is rolled back. + // the inner is committed but outer is rolled back. } NewVar(i) => { diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 87151708812e5..007f3014138e9 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1739,7 +1739,7 @@ pub struct ViewItem { impl Clean> for ast::ViewItem { fn clean(&self) -> Vec { - // We consider inlining the documentation of `pub use` statments, but we + // We consider inlining the documentation of `pub use` statements, but we // forcefully don't inline if this is not public or if the // #[doc(no_inline)] attribute is present. let denied = self.vis != ast::Public || self.attrs.iter().any(|a| { diff --git a/src/librustrt/c_str.rs b/src/librustrt/c_str.rs index 9734ba2d7518e..161d3ed5e65e1 100644 --- a/src/librustrt/c_str.rs +++ b/src/librustrt/c_str.rs @@ -376,7 +376,7 @@ pub trait ToCStr { // (without forcing an additional & around &str). So we are instead // temporarily adding an instance for ~str and String, so that we can // take ToCStr as owned. When DST lands, the string instances should -// be revisted, and arguments bound by ToCStr should be passed by +// be revisited, and arguments bound by ToCStr should be passed by // reference. impl<'a> ToCStr for &'a str { diff --git a/src/librustrt/libunwind.rs b/src/librustrt/libunwind.rs index 6811a62c74f52..f018b3fc16b3b 100644 --- a/src/librustrt/libunwind.rs +++ b/src/librustrt/libunwind.rs @@ -97,7 +97,7 @@ extern {} extern "C" { // iOS on armv7 uses SjLj exceptions and requires to link - // agains corresponding routine (..._SjLj_...) + // against corresponding routine (..._SjLj_...) #[cfg(not(target_os = "ios", target_arch = "arm"))] pub fn _Unwind_RaiseException(exception: *mut _Unwind_Exception) -> _Unwind_Reason_Code; diff --git a/src/librustrt/task.rs b/src/librustrt/task.rs index 891d0d5a8e359..59401a8b66604 100644 --- a/src/librustrt/task.rs +++ b/src/librustrt/task.rs @@ -170,7 +170,7 @@ impl Task { /// This function can be used as an emulated "try/catch" to interoperate /// with the rust runtime at the outermost boundary. It is not possible to /// use this function in a nested fashion (a try/catch inside of another - /// try/catch). Invoking this funciton is quite cheap. + /// try/catch). Invoking this function is quite cheap. /// /// If the closure `f` succeeds, then the returned task can be used again /// for another invocation of `run`. If the closure `f` fails then `self` @@ -276,7 +276,7 @@ impl Task { // 1. If TLD destruction fails, heap destruction will be attempted. // There is a test for this at fail-during-tld-destroy.rs. Sadly the // other way can't be tested due to point 2 above. Note that we must - // immortalize the heap first becuase if any deallocations are + // immortalize the heap first because if any deallocations are // attempted while TLD is being dropped it will attempt to free the // allocation from the wrong heap (because the current one has been // replaced). diff --git a/src/librustrt/thread.rs b/src/librustrt/thread.rs index 9908e87e86a47..59784328cdb50 100644 --- a/src/librustrt/thread.rs +++ b/src/librustrt/thread.rs @@ -243,7 +243,7 @@ mod imp { // EINVAL means |stack_size| is either too small or not a // multiple of the system page size. Because it's definitely // >= PTHREAD_STACK_MIN, it must be an alignment issue. - // Round up to the neareast page and try again. + // Round up to the nearest page and try again. let page_size = libc::sysconf(libc::_SC_PAGESIZE) as uint; let stack_size = (stack_size + page_size - 1) & (-(page_size as int - 1) as uint - 1); diff --git a/src/librustuv/lib.rs b/src/librustuv/lib.rs index 968a283995bef..a1712394634b8 100644 --- a/src/librustuv/lib.rs +++ b/src/librustuv/lib.rs @@ -234,7 +234,7 @@ impl ForbidUnwind { impl Drop for ForbidUnwind { fn drop(&mut self) { assert!(self.failing_before == task::failing(), - "didnt want an unwind during: {}", self.msg); + "didn't want an unwind during: {}", self.msg); } } diff --git a/src/librustuv/stream.rs b/src/librustuv/stream.rs index f6b9226588ca3..875c2dee46b4f 100644 --- a/src/librustuv/stream.rs +++ b/src/librustuv/stream.rs @@ -87,7 +87,7 @@ impl StreamWatcher { // immediately as part of the call to alloc_cb. What this means is that // we must be ready for this to happen (by setting the data in the uv // handle). In theory this otherwise doesn't need to happen until after - // the read is succesfully started. + // the read is successfully started. unsafe { uvll::set_data_for_uv_handle(self.handle, &mut rcx) } // Send off the read request, but don't block until we're sure that the diff --git a/src/librustuv/timer.rs b/src/librustuv/timer.rs index 9d0a56b3c851d..f6c1cdd297754 100644 --- a/src/librustuv/timer.rs +++ b/src/librustuv/timer.rs @@ -77,7 +77,7 @@ impl RtioTimer for TimerWatcher { fn sleep(&mut self, msecs: u64) { // As with all of the below functions, we must be extra careful when // destroying the previous action. If the previous action was a channel, - // destroying it could invoke a context switch. For these situtations, + // destroying it could invoke a context switch. For these situations, // we must temporarily un-home ourselves, then destroy the action, and // then re-home again. let missile = self.fire_homing_missile(); diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index 2c54bd895e952..ca59849202b08 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -410,7 +410,7 @@ mod test { // colon after v4 let none: Option = FromStr::from_str("::127.0.0.1:"); assert_eq!(None, none); - // not enought groups + // not enough groups let none: Option = FromStr::from_str("1.2.3.4.5:127.0.0.1"); assert_eq!(None, none); // too many groups diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 6674dd532aeb0..7278ff9f72fdf 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -469,7 +469,7 @@ pub fn unsetenv(n: &str) { /// println!("'{}'", path.display()); /// } /// } -/// None => println!("{} is not defined in the environnement.", key) +/// None => println!("{} is not defined in the environment.", key) /// } /// ``` pub fn split_paths(unparsed: T) -> Vec { diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs index 8f51e834c6a02..2e0dcdd8eb69f 100644 --- a/src/libstd/rt/backtrace.rs +++ b/src/libstd/rt/backtrace.rs @@ -266,7 +266,7 @@ mod imp { } // while it doesn't requires lock for work as everything is - // local, it still displays much nicier backtraces when a + // local, it still displays much nicer backtraces when a // couple of tasks fail simultaneously static mut LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT; let _g = unsafe { LOCK.lock() }; diff --git a/src/libsync/comm/oneshot.rs b/src/libsync/comm/oneshot.rs index bf2d9aa52fd24..742686069e283 100644 --- a/src/libsync/comm/oneshot.rs +++ b/src/libsync/comm/oneshot.rs @@ -354,7 +354,7 @@ impl Packet { } // We woke ourselves up from select. Assert that the task should be - // trashed and returne that we don't have any data. + // trashed and returned that we don't have any data. n => { let t = unsafe { BlockedTask::cast_from_uint(n) }; t.trash(); diff --git a/src/libsync/comm/shared.rs b/src/libsync/comm/shared.rs index a50a6bbc8d31f..5ad4dea5d2a89 100644 --- a/src/libsync/comm/shared.rs +++ b/src/libsync/comm/shared.rs @@ -81,7 +81,7 @@ impl Packet { // This function should be used after newly created Packet // was wrapped with an Arc - // In other case mutex data will be duplicated while clonning + // In other case mutex data will be duplicated while cloning // and that could cause problems on platforms where it is // represented by opaque data structure pub fn postinit_lock(&mut self) { @@ -140,7 +140,7 @@ impl Packet { // See Port::drop for what's going on if self.port_dropped.load(atomics::SeqCst) { return Err(t) } - // Note that the multiple sender case is a little tricker + // Note that the multiple sender case is a little trickier // semantically than the single sender case. The logic for // incrementing is "add and if disconnected store disconnected". // This could end up leading some senders to believe that there diff --git a/src/libsync/mutex.rs b/src/libsync/mutex.rs index ef558d3f9241b..a10ec7458690a 100644 --- a/src/libsync/mutex.rs +++ b/src/libsync/mutex.rs @@ -215,7 +215,7 @@ impl StaticMutex { None => {} } - // After we've failed the fast path, then we delegate to the differnet + // After we've failed the fast path, then we delegate to the different // locking protocols for green/native tasks. This will select two tasks // to continue further (one native, one green). let t: Box = Local::take(); diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 0d8373eac3c7f..ab5d70217469c 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -472,7 +472,7 @@ impl<'a> ExtCtxt<'a> { } /// Emit `msg` attached to `sp`, and stop compilation immediately. /// - /// `span_err` should be strongly prefered where-ever possible: + /// `span_err` should be strongly preferred where-ever possible: /// this should *only* be used when /// - continuing has a high risk of flow-on errors (e.g. errors in /// declaring a macro would cause all uses of that macro to diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index 2b97687dbf8c9..24178872277af 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -834,7 +834,7 @@ impl<'a> MethodDef<'a> { generic `deriving`"); } - // `ref` inside let matches is buggy. Causes havoc wih rusc. + // `ref` inside let matches is buggy. Causes havoc with rusc. // let (variant_index, ref self_vec) = matches_so_far[0]; let (variant, self_vec) = match matches_so_far.get(0) { &(_, v, ref s) => (v, s) diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index b9cedb7a7797a..194b91d8ba8c6 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -1307,7 +1307,7 @@ mod test { } // create a really evil test case where a $x appears inside a binding of $x - // but *shouldnt* bind because it was inserted by a different macro.... + // but *shouldn't* bind because it was inserted by a different macro.... // can't write this test case until we have macro-generating macros. // FIXME #9383 : lambda var hygiene