---

yaml
---
r: 130493
b: refs/heads/try
c: f3f038c
h: refs/heads/master
i:
  130491: eacd7fc
v: v3

Author: brendanzab

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c964cb229bd342bdeb0b4506c3a6d32b03e575f6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 67b97ab6d2b7de9b69fd97dc171fcf8feec932ff
-refs/heads/try: d3e7922ddd5f2abfa4d5139e8bca5fab3e796f33
+refs/heads/try: f3f038c8566560e7367e0615d17ba104b71f6d8a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/driver/driver.rs

@@ -9,9 +9,9 @@
 // except according to those terms.
 
 #[cfg(rustdoc)]
-extern crate "rustdoc" as this;
+extern crate this = "rustdoc";
 
 #[cfg(rustc)]
-extern crate "rustc" as this;
+extern crate this = "rustc";
 
 fn main() { this::main() }

branches/try/src/libcollections/lib.rs

@@ -289,7 +289,7 @@ pub trait Set<T>: Collection {
 }
 
 /// A mutable collection of values which are distinct from one another that
-/// can be mutated.
+/// can be mutaed.
 pub trait MutableSet<T>: Set<T> + Mutable {
     /// Adds a value to the set. Returns `true` if the value was not already
     /// present in the set.

branches/try/src/libcollections/ringbuf.rs

@@ -132,7 +132,7 @@ impl<T> RingBuf<T> {
               elts: Vec::from_fn(cmp::max(MINIMUM_CAPACITY, n), |_| None)}
     }
 
-    /// Retrieve an element in the `RingBuf` by index.
+    /// Retrieva an element in the `RingBuf` by index.
     ///
     /// Fails if there is no element with the given index.
     ///

branches/try/src/libcollections/smallintmap.rs

@@ -324,7 +324,7 @@ impl<V:Clone> SmallIntMap<V> {
     /// Updates a value in the map. If the key already exists in the map,
     /// modifies the value with `ff` taking `oldval, newval`.
     /// Otherwise, sets the value to `newval`.
-    /// Returns `true` if the key did not already exist in the map.
+    /// Returasn `true` if the key did not already exist in the map.
     ///
     /// # Example
     ///

branches/try/src/libcollections/str.rs

@@ -44,7 +44,7 @@
 //!
 //! # Representation
 //!
-//! Rust's string type, `str`, is a sequence of Unicode scalar values encoded as a
+//! Rust's string type, `str`, is a sequence of unicode scalar values encoded as a
 //! stream of UTF-8 bytes. All strings are guaranteed to be validly encoded UTF-8
 //! sequences. Additionally, strings are not null-terminated and can contain null
 //! bytes.

branches/try/src/libcore/char.rs

@@ -201,7 +201,7 @@ pub fn escape_unicode(c: char, f: |char|) {
 /// - Tab, CR and LF are escaped as '\t', '\r' and '\n' respectively.
 /// - Single-quote, double-quote and backslash chars are backslash-escaped.
 /// - Any other chars in the range [0x20,0x7e] are not escaped.
-/// - Any other chars are given hex Unicode escapes; see `escape_unicode`.
+/// - Any other chars are given hex unicode escapes; see `escape_unicode`.
 ///
 pub fn escape_default(c: char, f: |char|) {
     match c {
@@ -290,7 +290,7 @@ pub trait Char {
     /// * Single-quote, double-quote and backslash chars are backslash-
     ///   escaped.
     /// * Any other chars in the range [0x20,0x7e] are not escaped.
-    /// * Any other chars are given hex Unicode escapes; see `escape_unicode`.
+    /// * Any other chars are given hex unicode escapes; see `escape_unicode`.
     fn escape_default(&self, f: |char|);
 
     /// Returns the amount of bytes this character would need if encoded in

branches/try/src/libcore/intrinsics.rs

@@ -311,7 +311,7 @@ extern "rust-intrinsic" {
 
     /// Gives the address for the return value of the enclosing function.
     ///
-    /// Using this intrinsic in a function that does not use an out pointer
+    /// Using this instrinsic in a function that does not use an out pointer
     /// will trigger a compiler error.
     pub fn return_address() -> *const u8;
 

branches/try/src/libcore/str.rs

@@ -1128,7 +1128,7 @@ pub trait StrSlice<'a> {
     fn contains_char(&self, needle: char) -> bool;
 
     /// An iterator over the characters of `self`. Note, this iterates
-    /// over Unicode code-points, not Unicode graphemes.
+    /// over unicode code-points, not unicode graphemes.
     ///
     /// # Example
     ///
@@ -1505,7 +1505,7 @@ pub trait StrSlice<'a> {
     /// Pluck a character out of a string and return the index of the next
     /// character.
     ///
-    /// This function can be used to iterate over the Unicode characters of a
+    /// This function can be used to iterate over the unicode characters of a
     /// string.
     ///
     /// # Example
@@ -1549,7 +1549,7 @@ pub trait StrSlice<'a> {
     /// # Return value
     ///
     /// A record {ch: char, next: uint} containing the char value and the byte
-    /// index of the next Unicode character.
+    /// index of the next unicode character.
     ///
     /// # Failure
     ///
@@ -1559,7 +1559,7 @@ pub trait StrSlice<'a> {
 
     /// Given a byte position and a str, return the previous char and its position.
     ///
-    /// This function can be used to iterate over a Unicode string in reverse.
+    /// This function can be used to iterate over a unicode string in reverse.
     ///
     /// Returns 0 for next index if called on start index 0.
     ///

branches/try/src/liblibc/lib.rs

@@ -65,7 +65,7 @@
 * definitions common-to-all (held in modules named c95, c99, posix88, posix01
 * and posix08) and definitions that appear only on *some* platforms (named
 * 'extra'). This would be things like significant OSX foundation kit, or Windows
-* library kernel32.dll, or various fancy glibc, Linux or BSD extensions.
+* library kernel32.dll, or various fancy glibc, linux or BSD extensions.
 *
 * In addition to the per-platform 'extra' modules, we define a module of
 * 'common BSD' libc routines that never quite made it into POSIX but show up

branches/try/src/libnative/io/net.rs

@@ -901,8 +901,8 @@ 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 fiddling, no affecting other objects), but not on
+// linux [1] [2]. This means that it's pretty easy to get a nonblocking
+// 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
@@ -922,7 +922,7 @@ impl rtio::RtioUdpSocket for UdpSocket {
 // operations performed in the lock are *nonblocking* to avoid holding the mutex
 // forever.
 //
-// So, in summary, Linux uses MSG_DONTWAIT and doesn't need mutexes, everyone
+// So, in summary, linux uses MSG_DONTWAIT and doesn't need mutexes, everyone
 // else uses O_NONBLOCK and mutexes with some trickery to make sure blocking
 // reads/writes are still blocking.
 //

branches/try/src/libnative/io/pipe_windows.rs

@@ -655,7 +655,7 @@ impl UnixAcceptor {
         // using the original server pipe.
         let handle = self.listener.handle;
 
-        // If we've had an artificial call to close_accept, be sure to never
+        // If we've had an artifical call to close_accept, be sure to never
         // proceed in accepting new clients in the future
         if self.inner.closed.load(atomic::SeqCst) { return Err(util::eof()) }
 

branches/try/src/libnative/io/process.rs

@@ -151,7 +151,7 @@ impl rtio::RtioProcess for Process {
         #[cfg(unix)] use libc::EINVAL as ERROR;
         #[cfg(windows)] use libc::ERROR_NOTHING_TO_TERMINATE as ERROR;
 
-        // On Linux (and possibly other unices), a process that has exited will
+        // On linux (and possibly other unices), a process that has exited will
         // continue to accept signals because it is "defunct". The delivery of
         // signals will only fail once the child has been reaped. For this
         // reason, if the process hasn't exited yet, then we attempt to collect

branches/try/src/libnative/io/timer_unix.rs

@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Timers for non-Linux/non-Windows OSes
+//! Timers for non-linux/non-windows OSes
 //!
 //! This module implements timers with a worker thread, select(), and a lot of
 //! witchcraft that turns out to be horribly inaccurate timers. The unfortunate
 //! part is that I'm at a loss of what else to do one these OSes. This is also
-//! why Linux has a specialized timerfd implementation and windows has its own
+//! why linux has a specialized timerfd implementation and windows has its own
 //! implementation (they're more accurate than this one).
 //!
 //! The basic idea is that there is a worker thread that's communicated to via a

branches/try/src/libnative/io/tty_windows.rs

@@ -15,7 +15,7 @@
 //! This module contains the implementation of a Windows specific console TTY.
 //! Also converts between UTF-16 and UTF-8. Windows has very poor support for
 //! UTF-8 and some functions will fail. In particular ReadFile and ReadConsole
-//! will fail when the codepage is set to UTF-8 and a Unicode character is
+//! will fail when the codepage is set to UTF-8 and a unicode character is
 //! entered.
 //!
 //! FIXME

branches/try/src/libregex/lib.rs

@@ -372,7 +372,7 @@
 #![deny(missing_doc)]
 
 #[cfg(test)]
-extern crate "test" as stdtest;
+extern crate stdtest = "test";
 #[cfg(test)]
 extern crate rand;
 
@@ -381,7 +381,7 @@ extern crate rand;
 #[cfg(test)]
 extern crate regex;
 
-// Unicode tables for character classes are defined in libunicode
+// unicode tables for character classes are defined in libunicode
 extern crate unicode;
 
 pub use parse::Error;

branches/try/src/libregex/parse.rs

@@ -620,9 +620,9 @@ impl<'a> Parser<'a> {
         }
     }
 
-    // Parses a Unicode character class name, either of the form \pF where
-    // F is a one letter Unicode class name or of the form \p{name} where
-    // name is the Unicode class name.
+    // Parses a unicode character class name, either of the form \pF where
+    // F is a one letter unicode class name or of the form \p{name} where
+    // name is the unicode class name.
     // Assumes that \p or \P has been read (and 'p' or 'P' is the current
     // character).
     fn parse_unicode_name(&mut self) -> Result<Ast, Error> {

branches/try/src/libregex/vm.rs

@@ -364,7 +364,7 @@ impl<'t> CharReader<'t> {
     }
 
     /// Sets the previous and current character given any arbitrary byte
-    /// index (at a Unicode codepoint boundary).
+    /// index (at a unicode codepoint boundary).
     #[inline]
     pub fn set(&mut self, ic: uint) -> uint {
         self.prev = None;

branches/try/src/librustc/back/link.rs

@@ -1748,7 +1748,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session,
         //
         // We must continue to link to the upstream archives to be sure
         // to pull in native static dependencies. As the final caveat,
-        // on Linux it is apparently illegal to link to a blank archive,
+        // on linux it is apparently illegal to link to a blank archive,
         // so if an archive no longer has any object files in it after
         // we remove `lib.o`, then don't link against it at all.
         //

branches/try/src/librustc/back/lto.rs

@@ -162,7 +162,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
 
         "verify".with_c_str(|s| llvm::LLVMRustAddPass(pm, s));
 
-        time(sess.time_passes(), "LTO passes", (), |()|
+        time(sess.time_passes(), "LTO pases", (), |()|
              llvm::LLVMRunPassManager(pm, llmod));
 
         llvm::LLVMDisposePassManager(pm);

branches/try/src/librustc/front/std_inject.rs

@@ -62,7 +62,7 @@ struct StandardLibraryInjector<'a> {
 impl<'a> fold::Folder for StandardLibraryInjector<'a> {
     fn fold_crate(&mut self, mut krate: ast::Crate) -> ast::Crate {
 
-        // The name to use in `extern crate "name" as std;`
+        // The name to use in `extern crate std = "name";`
         let actual_crate_name = match self.sess.opts.alt_std_name {
             Some(ref s) => token::intern_and_get_ident(s.as_slice()),
             None => token::intern_and_get_ident("std"),

branches/try/src/librustc/lib.rs

@@ -42,8 +42,8 @@ extern crate flate;
 extern crate getopts;
 extern crate graphviz;
 extern crate libc;
-extern crate "rustc_llvm" as llvm;
-extern crate "rustc_back" as rustc_back;
+extern crate llvm = "rustc_llvm";
+extern crate rustc_back = "rustc_back";
 extern crate serialize;
 extern crate rbml;
 extern crate time;

branches/try/src/librustc/middle/const_eval.rs

@@ -56,7 +56,7 @@ use std::gc::{Gc, GC};
 //        copies of general constants
 //
 //        (in theory, probably not at first: if/match on integer-const
-//         conditions / discriminants)
+//         conditions / descriminants)
 //
 //   - Non-constants: everything else.
 //

branches/try/src/librustc/middle/trans/base.rs

@@ -1068,7 +1068,7 @@ pub fn load_ty(cx: &Block, ptr: ValueRef, t: ty::t) -> ValueRef {
     } else if ty::type_is_bool(t) {
         Trunc(cx, LoadRangeAssert(cx, ptr, 0, 2, llvm::False), Type::i1(cx.ccx()))
     } else if ty::type_is_char(t) {
-        // a char is a Unicode codepoint, and so takes values from 0
+        // a char is a unicode codepoint, and so takes values from 0
         // to 0x10FFFF inclusive only.
         LoadRangeAssert(cx, ptr, 0, 0x10FFFF + 1, llvm::False)
     } else {

branches/try/src/librustc/middle/trans/debuginfo.rs

@@ -740,7 +740,7 @@ pub fn finalize(cx: &CrateContext) {
             "Dwarf Version".with_c_str(
                 |s| llvm::LLVMRustAddModuleFlag(cx.llmod, s, 2));
         } else {
-            // FIXME(#13611) this is a kludge fix because the Linux bots have
+            // FIXME(#13611) this is a kludge fix because the linux bots have
             //               gdb 7.4 which doesn't understand dwarf4, we should
             //               do something more graceful here.
             "Dwarf Version".with_c_str(

branches/try/src/librustc/middle/trans/expr.rs

@@ -1386,7 +1386,7 @@ pub fn trans_adt<'a>(mut bcx: &'a Block<'a>,
         }
     }
 
-    // Now, we just overwrite the fields we've explicitly specified
+    // Now, we just overwrite the fields we've explicity specified
     for &(i, ref e) in fields.iter() {
         let dest = adt::trans_field_ptr(bcx, &*repr, addr, discr, i);
         let e_ty = expr_ty_adjusted(bcx, &**e);

branches/try/src/librustc/middle/ty.rs

@@ -903,7 +903,7 @@ pub enum sty {
     /// Substs here, possibly against intuition, *may* contain `ty_param`s.
     /// That is, even after substitution it is possible that there are type
     /// variables. This happens when the `ty_enum` corresponds to an enum
-    /// definition and not a concrete use of it. To get the correct `ty_enum`
+    /// definition and not a concerete use of it. To get the correct `ty_enum`
     /// from the tcx, use the `NodeId` from the `ast::Ty` and look it up in
     /// the `ast_ty_to_ty_cache`. This is probably true for `ty_struct` as
     /// well.`

branches/try/src/librustc/util/snapshot_vec.rs

@@ -148,12 +148,12 @@ impl<T,U,D:SnapshotVecDelegate<T,U>> SnapshotVec<T,U,D> {
             match self.undo_log.pop().unwrap() {
                 OpenSnapshot => {
                     // This indicates a failure to obey the stack discipline.
-                    fail!("Cannot rollback an uncommitted snapshot");
+                    fail!("Cannot rollback an uncommited snapshot");
                 }
 
                 CommittedSnapshot => {
                     // This occurs when there are nested snapshots and
-                    // the inner is committed but outer is rolled back.
+                    // the inner is commited but outer is rolled back.
                 }
 
                 NewElem(i) => {

branches/try/src/librustc_back/x86_64.rs

@@ -30,7 +30,7 @@ pub fn get_target_strs(target_triple: String, target_os: abi::Os) -> target_strs
           }
 
           abi::OsWindows => {
-            // FIXME: Test this. Copied from Linux (#2398)
+            // FIXME: Test this. Copied from linux (#2398)
             "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-\
                 f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-\
                 s0:64:64-f80:128:128-n8:16:32:64-S128".to_string()

branches/try/src/librustdoc/html/render.rs

@@ -1155,7 +1155,7 @@ impl Context {
 
             // We have a huge number of calls to write, so try to alleviate some
             // of the pain by using a buffered writer instead of invoking the
-            // write syscall all the time.
+            // write sycall all the time.
             let mut writer = BufferedWriter::new(w);
             if !cx.render_redirect_pages {
                 try!(layout::render(&mut writer, &cx.layout, &page,

branches/try/src/librustdoc/lib.rs

@@ -23,7 +23,7 @@ extern crate libc;
 extern crate rustc;
 extern crate serialize;
 extern crate syntax;
-extern crate "test" as testing;
+extern crate testing = "test";
 extern crate time;
 #[phase(plugin, link)] extern crate log;
 

branches/try/src/librustdoc/stability_summary.rs

@@ -11,7 +11,7 @@
 //! This module crawls a `clean::Crate` and produces a summarization of the
 //! stability levels within the crate. The summary contains the module
 //! hierarchy, with item counts for every stability level per module. A parent
-//! module's count includes its children's.
+//! module's count includes its childrens's.
 
 use std::ops::Add;
 use std::num::Zero;

branches/try/src/librustrt/args.rs

@@ -14,7 +14,7 @@
 //! the processes `argc` and `argv` arguments to be stored
 //! in a globally-accessible location for use by the `os` module.
 //!
-//! Only valid to call on Linux. Mac and Windows use syscalls to
+//! Only valid to call on linux. Mac and Windows use syscalls to
 //! discover the command line arguments.
 //!
 //! FIXME #7756: Would be nice for this to not exist.

branches/try/src/librustrt/c_str.rs

@@ -19,7 +19,7 @@ string types are *not* null terminated.
 
 The other problem with translating Rust strings to C strings is that Rust
 strings can validly contain a null-byte in the middle of the string (0 is a
-valid Unicode codepoint). This means that not all Rust strings can actually be
+valid unicode codepoint). This means that not all Rust strings can actually be
 translated to C strings.
 
 # Creation of a C string

branches/try/src/librustrt/lib.rs

@@ -27,7 +27,7 @@ extern crate alloc;
 extern crate libc;
 extern crate collections;
 
-#[cfg(test)] extern crate "rustrt" as realrustrt;
+#[cfg(test)] extern crate realrustrt = "rustrt";
 #[cfg(test)] extern crate test;
 #[cfg(test)] extern crate native;