Fix misspelled comments.

src/compiletest/common.rs

@@ -136,7 +136,7 @@ pub struct Config {
     // Extra parameter to run adb on arm-linux-androideabi
     pub adb_path: String,
 
-    // Extra parameter to run test sute on arm-linux-androideabi
+    // Extra parameter to run test suite on arm-linux-androideabi
     pub adb_test_dir: String,
 
     // status whether android device available or not

src/compiletest/runtest.rs

@@ -325,7 +325,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
     let DebuggerCommands { commands, check_lines, .. } = parse_debugger_commands(testfile, "gdb");
     let mut cmds = commands.connect("\n");
 
-    // compile test file (it shoud have 'compile-flags:-g' in the header)
+    // compile test file (it should have 'compile-flags:-g' in the header)
     let compiler_run_result = compile_test(config, props, testfile);
     if !compiler_run_result.status.success() {
         fatal_proc_rec("compilation failed!", &compiler_run_result);
@@ -520,7 +520,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
 
     let config = &mut config;
 
-    // compile test file (it shoud have 'compile-flags:-g' in the header)
+    // compile test file (it should have 'compile-flags:-g' in the header)
     let compile_result = compile_test(config, props, testfile);
     if !compile_result.status.success() {
         fatal_proc_rec("compilation failed!", &compile_result);

src/libcollections/bitv.rs

@@ -1517,7 +1517,7 @@ pub struct BitPositions<'a> {
     next_idx: uint
 }
 
-/// An iterator combining wo `BitvSet` iterators.
+/// An iterator combining two `BitvSet` iterators.
 pub struct TwoBitPositions<'a> {
     set: &'a BitvSet,
     other: &'a BitvSet,

src/libcollections/priority_queue.rs

@@ -119,7 +119,7 @@
 //!     //           10      |               |
 //!     //                   +---------------+
 //!     //
-//!     // The graph is represented as an adjecency list where each index,
+//!     // The graph is represented as an adjacency list where each index,
 //!     // corresponding to a node value, has a list of outgoing edges.
 //!     // Chosen for it's efficiency.
 //!     let graph = vec![

src/libcollections/string.rs

@@ -842,7 +842,7 @@ pub mod raw {
     /// Create a `String` from a null-terminated *u8 buffer
     ///
     /// This function is unsafe because we dereference memory until we find the NUL character,
-    /// which is not guaranteed to be present. Additionaly, the slice is not checked to see
+    /// which is not guaranteed to be present. Additionally, the slice is not checked to see
     /// whether it contains valid UTF-8
     pub unsafe fn from_buf(buf: *const u8) -> String {
         let mut len = 0;

src/libcore/cell.rs

@@ -449,7 +449,7 @@ pub struct UnsafeCell<T> {
 }
 
 impl<T> UnsafeCell<T> {
-    /// Construct a new instance of `UnsafeCell` which will wrapp the specified
+    /// Construct a new instance of `UnsafeCell` which will wrap the specified
     /// value.
     ///
     /// All access to the inner value through methods is `unsafe`, and it is

src/libgreen/task.rs

@@ -118,7 +118,7 @@ extern fn bootstrap_green_task(task: uint, code: *mut (), env: *mut ()) -> ! {
     // preserving a handle to the GreenTask down to this point, this
     // unfortunately must call `GreenTask::convert`. In order to avoid
     // this we could add a `terminate` function to the `Runtime` trait
-    // in libstd, but that seems less appropriate since the coversion
+    // in libstd, but that seems less appropriate since the conversion
     // method exists.
     GreenTask::convert(task).terminate();
 }

src/libnative/io/net.rs

@@ -769,7 +769,7 @@ impl rtio::RtioUdpSocket for UdpSocket {
 // It turns out that there's this nifty MSG_DONTWAIT flag which can be passed to
 // send/recv, but the niftiness wears off once you realize it only works well on
 // linux [1] [2]. This means that it's pretty easy to get a nonblocking
-// operation on linux (no flag fidding, no affecting other objects), but not on
+// operation on linux (no flag fiddling, no affecting other objects), but not on
 // other platforms.
 //
 // To work around this constraint on other platforms, we end up using the

src/libnative/io/pipe_win32.rs

@@ -311,7 +311,7 @@ impl UnixStream {
                     }
                 }
 
-                // An example I found on microsoft's website used 20
+                // An example I found on Microsoft's website used 20
                 // seconds, libuv uses 30 seconds, hence we make the
                 // obvious choice of waiting for 25 seconds.
                 None => {

src/librustc/metadata/loader.rs

@@ -11,7 +11,7 @@
 //! Finds crate binaries and loads their metadata
 //!
 //! Might I be the first to welcome you to a world of platform differences,
-//! version requirements, dependency graphs, conficting desires, and fun! This
+//! version requirements, dependency graphs, conflicting desires, and fun! This
 //! is the major guts (along with metadata::creader) of the compiler for loading
 //! crates and resolving dependencies. Let's take a tour!
 //!
@@ -83,7 +83,7 @@
 //! 5. Does the target in the metadata agree with the current target?
 //! 6. Does the SVH match? (more on this later)
 //!
-//! If the file answeres `yes` to all these questions, then the file is
+//! If the file answers `yes` to all these questions, then the file is
 //! considered as being *candidate* for being accepted. It is illegal to have
 //! more than two candidates as the compiler has no method by which to resolve
 //! this conflict. Additionally, rlib/dylib candidates are considered
@@ -173,7 +173,7 @@
 //! ## Loading transitive dependencies
 //!
 //! Dealing with same-named-but-distinct crates is not just a local problem, but
-//! one that also needs to be dealt with for transitive dependences. Note that
+//! one that also needs to be dealt with for transitive dependencies. Note that
 //! in the letter above `--extern` flags only apply to the *local* set of
 //! dependencies, not the upstream transitive dependencies. Consider this
 //! dependency graph:
@@ -660,7 +660,7 @@ impl<'a> Context<'a> {
             false
         });
 
-        // Now that we have an itertor of good candidates, make sure there's at
+        // Now that we have an iterator of good candidates, make sure there's at
         // most one rlib and at most one dylib.
         let mut rlibs = HashSet::new();
         let mut dylibs = HashSet::new();

src/librustc/middle/ty.rs

@@ -269,7 +269,7 @@ pub struct ctxt {
 
     /// Stores the type parameters which were substituted to obtain the type
     /// of this node.  This only applies to nodes that refer to entities
-    /// param<eterized by type parameters, such as generic fns, types, or
+    /// parameterized by type parameters, such as generic fns, types, or
     /// other items.
     pub item_substs: RefCell<NodeMap<ItemSubsts>>,
 

src/librustdoc/html/render.rs

@@ -1098,7 +1098,7 @@ impl Context {
         Ok(())
     }
 
-    /// Non-parellelized version of rendering an item. This will take the input
+    /// Non-parallelized version of rendering an item. This will take the input
     /// item, render its contents, and then invoke the specified closure with
     /// all sub-items which need to be rendered.
     ///

src/librustdoc/stability_summary.rs

@@ -60,7 +60,7 @@ impl Counts {
 }
 
 #[deriving(Encodable, Decodable, PartialEq, Eq)]
-/// A summarized module, which includes total counts and summarized chilcren
+/// A summarized module, which includes total counts and summarized children
 /// modules.
 pub struct ModuleSummary {
     pub name: String,

src/librustuv/stream.rs

@@ -28,7 +28,7 @@ pub struct StreamWatcher {
     // Cache the last used uv_write_t so we don't have to allocate a new one on
     // every call to uv_write(). Ideally this would be a stack-allocated
     // structure, but currently we don't have mappings for all the structures
-    // defined in libuv, so we're foced to malloc this.
+    // defined in libuv, so we're forced to malloc this.
     last_write_req: Option<Request>,
 
     blocked_writer: Option<BlockedTask>,

src/libstd/collections/hashmap.rs

@@ -1937,7 +1937,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     /// # Example
     ///
     /// This is a slightly silly example where we define the number's
-    /// parity as the equivilance class. It is important that the
+    /// parity as the equivalence class. It is important that the
     /// values hash the same, which is why we implement `Hash`.
     ///
     /// ```rust

src/libstd/io/net/addrinfo.rs

@@ -79,7 +79,7 @@ pub fn get_host_addresses(host: &str) -> IoResult<Vec<IpAddr>> {
     lookup(Some(host), None, None).map(|a| a.move_iter().map(|i| i.address.ip).collect())
 }
 
-/// Full-fleged resolution. This function will perform a synchronous call to
+/// Full-fledged resolution. This function will perform a synchronous call to
 /// getaddrinfo, controlled by the parameters
 ///
 /// # Arguments

src/libstd/os.rs

@@ -873,7 +873,7 @@ pub fn make_absolute(p: &Path) -> Path {
 ///
 /// let root = Path::new("/");
 /// assert!(os::change_dir(&root));
-/// println!("Succesfully changed working directory to {}!", root.display());
+/// println!("Successfully changed working directory to {}!", root.display());
 /// ```
 pub fn change_dir(p: &Path) -> bool {
     return chdir(p);

src/libsync/lock.rs

@@ -223,7 +223,7 @@ impl<T: Send> Mutex<T> {
     pub fn lock<'a>(&'a self) -> MutexGuard<'a, T> {
         let guard = self.lock.lock();
 
-        // These two accesses are safe because we're guranteed at this point
+        // These two accesses are safe because we're guaranteed at this point
         // that we have exclusive access to this mutex. We are indeed able to
         // promote ourselves from &Mutex to `&mut T`
         let poison = unsafe { &mut *self.failed.get() };
@@ -326,7 +326,7 @@ impl<T: Send + Share> RWLock<T> {
     pub fn write<'a>(&'a self) -> RWLockWriteGuard<'a, T> {
         let guard = self.lock.write();
 
-        // These two accesses are safe because we're guranteed at this point
+        // These two accesses are safe because we're guaranteed at this point
         // that we have exclusive access to this rwlock. We are indeed able to
         // promote ourselves from &RWLock to `&mut T`
         let poison = unsafe { &mut *self.failed.get() };

src/libsyntax/attr.rs

@@ -426,7 +426,7 @@ pub fn require_unique_names(diagnostic: &SpanHandler, metas: &[Gc<MetaItem>]) {
 /// not allowed on univariant or zero-variant enums, which have no discriminant.
 ///
 /// If a discriminant type is so specified, then the discriminant will be
-/// present (before fields, if any) with that type; reprensentation
+/// present (before fields, if any) with that type; representation
 /// optimizations which would remove it will not be done.
 pub fn find_repr_attr(diagnostic: &SpanHandler, attr: &Attribute, acc: ReprAttr)
     -> ReprAttr {

src/libsyntax/ext/deriving/encodable.rs

@@ -41,7 +41,7 @@
 //! }
 //! ```
 //!
-//! Other interesting scenarios are whe the item has type parameters or
+//! Other interesting scenarios are when the item has type parameters or
 //! references other non-built-in types.  A type definition like:
 //!
 //! ```ignore

src/libsyntax/parse/parser.rs

@@ -4356,7 +4356,7 @@ impl<'a> Parser<'a> {
         return self.parse_single_struct_field(Inherited, attrs);
     }
 
-    /// Parse visiility: PUB, PRIV, or nothing
+    /// Parse visibility: PUB, PRIV, or nothing
     fn parse_visibility(&mut self) -> Visibility {
         if self.eat_keyword(keywords::Pub) { Public }
         else { Inherited }

src/libsyntax/print/pp.rs

@@ -225,12 +225,12 @@ pub fn mk_printer(out: Box<io::Writer>, linewidth: uint) -> Printer {
 /// 'right' indices denote the active portion of the ring buffer as well as
 /// describing hypothetical points-in-the-infinite-stream at most 3N tokens
 /// apart (i.e. "not wrapped to ring-buffer boundaries"). The paper will switch
-/// between using 'left' and 'right' terms to denote the wrapepd-to-ring-buffer
+/// between using 'left' and 'right' terms to denote the wrapped-to-ring-buffer
 /// and point-in-infinite-stream senses freely.
 ///
 /// There is a parallel ring buffer, 'size', that holds the calculated size of
 /// each token. Why calculated? Because for Begin/End pairs, the "size"
-/// includes everything betwen the pair. That is, the "size" of Begin is
+/// includes everything between the pair. That is, the "size" of Begin is
 /// actually the sum of the sizes of everything between Begin and the paired
 /// End that follows. Since that is arbitrarily far in the future, 'size' is
 /// being rewritten regularly while the printer runs; in fact most of the
@@ -270,7 +270,7 @@ pub struct Printer {
     left: uint,
     /// Index of right side of input stream
     right: uint,
-    /// Ring-buffr stream goes through
+    /// Ring-buffer stream goes through
     token: Vec<Token> ,
     /// Ring-buffer of calculated sizes
     size: Vec<int> ,