---

yaml
---
r: 152433
b: refs/heads/try2
c: c2c9946
h: refs/heads/master
i:
  152431: 7ed4ac0
v: v3

Author: jbcrail

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 7f777a5ba49785a74e5365e9897ddf4c02ea8519
+refs/heads/try2: c2c99463720e758d5aa0bdcea19dc5b3dd67292c
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/liballoc/arc.rs

@@ -184,7 +184,7 @@ impl<T: Share + Send> Drop for Arc<T> {
 
         // This fence is needed to prevent reordering of use of the data and
         // deletion of the data. Because it is marked `Release`, the
-        // decreasing of the reference count sychronizes with this `Acquire`
+        // 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
         // happens before the deletion of the data.

branches/try2/src/libcore/fmt/mod.rs

@@ -539,7 +539,7 @@ impl<'a> Formatter<'a> {
     }
 
     /// Runs a callback, emitting the correct padding either before or
-    /// afterwards depending on whether right or left alingment is requested.
+    /// afterwards depending on whether right or left alignment is requested.
     fn with_padding(&mut self,
                     padding: uint,
                     default: rt::Alignment,

branches/try2/src/libcore/result.rs

@@ -105,7 +105,7 @@
 //! *Note: The actual definition of `Writer` uses `IoResult`, which
 //! is just a synonym for `Result<T, IoError>`.*
 //!
-//! This method doesn`t produce a value, but the write may
+//! This method doesn't produce a value, but the write may
 //! fail. It's crucial to handle the error case, and *not* write
 //! something like this:
 //!

branches/try2/src/libgetopts/lib.rs

@@ -163,7 +163,7 @@ pub struct OptGroup {
     pub occur: Occur
 }
 
-/// Describes wether an option is given at all or has a value.
+/// Describes whether an option is given at all or has a value.
 #[deriving(Clone, PartialEq)]
 enum Optval {
     Val(String),

branches/try2/src/libglob/lib.rs

@@ -44,6 +44,7 @@ use std::string::String;
  * pattern - see the `glob` function for more details.
  */
 pub struct Paths {
+    root: Path,
     dir_patterns: Vec<Pattern>,
     require_dir: bool,
     options: MatchOptions,
@@ -107,6 +108,7 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> Paths {
             // FIXME: How do we want to handle verbatim paths? I'm inclined to return nothing,
             // since we can't very well find all UNC shares with a 1-letter server name.
             return Paths {
+                root: root,
                 dir_patterns: Vec::new(),
                 require_dir: false,
                 options: options,
@@ -132,6 +134,7 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> Paths {
     }
 
     Paths {
+        root: root,
         dir_patterns: dir_patterns,
         require_dir: require_dir,
         options: options,

branches/try2/src/libgreen/context.rs

@@ -143,7 +143,6 @@ extern {
 // stacks are disabled.
 
 #[cfg(target_arch = "x86")]
-#[repr(C)]
 struct Registers {
     eax: u32, ebx: u32, ecx: u32, edx: u32,
     ebp: u32, esi: u32, edi: u32, esp: u32,
@@ -227,7 +226,7 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
     regs[RUSTRT_R14] = procedure.env as uint;
     regs[RUSTRT_R15] = fptr as uint;
 
-    // These registers are picked up by the regulard context switch paths. These
+    // These registers are picked up by the regular context switch paths. These
     // will put us in "mostly the right context" except for frobbing all the
     // arguments to the right place. We have the small trampoline code inside of
     // rust_bootstrap_green_task to do that.

branches/try2/src/libgreen/sched.rs

@@ -82,7 +82,7 @@ pub struct Scheduler {
     run_anything: bool,
     /// A fast XorShift rng for scheduler use
     rng: XorShiftRng,
-    /// A togglable idle callback
+    /// A toggleable idle callback
     idle_callback: Option<Box<PausableIdleCallback:Send>>,
     /// A countdown that starts at a random value and is decremented
     /// every time a yield check is performed. When it hits 0 a task
@@ -287,7 +287,7 @@ impl Scheduler {
 
         // After processing a message, we consider doing some more work on the
         // event loop. The "keep going" condition changes after the first
-        // iteration becase we don't want to spin here infinitely.
+        // iteration because we don't want to spin here infinitely.
         //
         // Once we start doing work we can keep doing work so long as the
         // iteration does something. Note that we don't want to starve the

branches/try2/src/liblibc/lib.rs

@@ -291,7 +291,7 @@ pub use types::os::arch::extra::{mach_timebase_info};
 extern {}
 
 /// A wrapper for a nullable pointer. Don't use this except for interacting
-/// with libc. Basically Option, but without the dependance on libstd.
+/// with libc. Basically Option, but without the dependence on libstd.
 // If/when libprim happens, this can be removed in favor of that
 pub enum Nullable<T> {
     Null,
@@ -3497,7 +3497,7 @@ pub mod consts {
 
 
 pub mod funcs {
-    // Thankfull most of c95 is universally available and does not vary by OS
+    // Thankfully most of c95 is universally available and does not vary by OS
     // or anything. The same is not true of POSIX.
 
     pub mod c95 {

branches/try2/src/libnative/io/c_win32.rs

@@ -20,7 +20,6 @@ pub static FIONBIO: libc::c_long = 0x8004667e;
 static FD_SETSIZE: uint = 64;
 pub static MSG_DONTWAIT: libc::c_int = 0;
 
-#[repr(C)]
 pub struct WSADATA {
     pub wVersion: libc::WORD,
     pub wHighVersion: libc::WORD,
@@ -33,7 +32,6 @@ pub struct WSADATA {
 
 pub type LPWSADATA = *mut WSADATA;
 
-#[repr(C)]
 pub struct fd_set {
     fd_count: libc::c_uint,
     fd_array: [libc::SOCKET, ..FD_SETSIZE],

branches/try2/src/libnative/io/mod.rs

@@ -152,13 +152,13 @@ fn keep_going(data: &[u8], f: |*u8, uint| -> i64) -> i64 {
 /// Implementation of rt::rtio's IoFactory trait to generate handles to the
 /// native I/O functionality.
 pub struct IoFactory {
-    _cannot_construct_outside_of_this_module: ()
+    cannot_construct_outside_of_this_module: ()
 }
 
 impl IoFactory {
     pub fn new() -> IoFactory {
         net::init();
-        IoFactory { _cannot_construct_outside_of_this_module: () }
+        IoFactory { cannot_construct_outside_of_this_module: () }
     }
 }
 

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

@@ -254,10 +254,7 @@ pub struct TcpStream {
 
 struct Inner {
     fd: sock_t,
-
-    // Unused on Linux, where this lock is not necessary.
-    #[allow(dead_code)]
-    lock: mutex::NativeMutex
+    lock: mutex::NativeMutex,
 }
 
 pub struct Guard<'a> {

branches/try2/src/libnative/io/pipe_unix.rs

@@ -58,10 +58,7 @@ fn addr_to_sockaddr_un(addr: &CString) -> IoResult<(libc::sockaddr_storage, uint
 
 struct Inner {
     fd: fd_t,
-
-    // Unused on Linux, where this lock is not necessary.
-    #[allow(dead_code)]
-    lock: mutex::NativeMutex
+    lock: mutex::NativeMutex,
 }
 
 impl Inner {

branches/try2/src/libnative/io/pipe_win32.rs

@@ -50,7 +50,7 @@
 //! it sounded like named pipes just weren't built for this kind of interaction,
 //! and the suggested solution was to use overlapped I/O.
 //!
-//! I don't realy know what overlapped I/O is, but my basic understanding after
+//! I don't really know what overlapped I/O is, but my basic understanding after
 //! reading about it is that you have an external Event which is used to signal
 //! I/O completion, passed around in some OVERLAPPED structures. As to what this
 //! is, I'm not exactly sure.

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

@@ -923,7 +923,7 @@ fn waitpid(pid: pid_t, deadline: u64) -> IoResult<rtio::ProcessExit> {
     // Register a new SIGCHLD handler, returning the reading half of the
     // self-pipe plus the old handler registered (return value of sigaction).
     //
-    // Be sure to set up the self-pipe first because as soon as we reigster a
+    // Be sure to set up the self-pipe first because as soon as we register a
     // handler we're going to start receiving signals.
     fn register_sigchld() -> (libc::c_int, c::sigaction) {
         unsafe {

branches/try2/src/libnative/task.rs

@@ -166,7 +166,7 @@ impl rt::Runtime for Ops {
     //
     // On a mildly unrelated note, it should also be pointed out that OS
     // condition variables are susceptible to spurious wakeups, which we need to
-    // be ready for. In order to accomodate for this fact, we have an extra
+    // be ready for. In order to accommodate for this fact, we have an extra
     // `awoken` field which indicates whether we were actually woken up via some
     // invocation of `reawaken`. This flag is only ever accessed inside the
     // lock, so there's no need to make it atomic.

branches/try2/src/librand/distributions/gamma.rs

@@ -81,6 +81,7 @@ struct GammaSmallShape {
 /// See `Gamma` for sampling from a Gamma distribution with general
 /// shape parameters.
 struct GammaLargeShape {
+    shape: f64,
     scale: f64,
     c: f64,
     d: f64
@@ -117,6 +118,7 @@ impl GammaLargeShape {
     fn new_raw(shape: f64, scale: f64) -> GammaLargeShape {
         let d = shape - 1. / 3.;
         GammaLargeShape {
+            shape: shape,
             scale: scale,
             c: 1. / (9. * d).sqrt(),
             d: d

branches/try2/src/libregex/compile.rs

@@ -34,7 +34,7 @@ pub enum Inst {
 
     // The CharClass instruction tries to match one input character against
     // the range of characters given.
-    // The flags indicate whether to do a case insentivie match and whether
+    // The flags indicate whether to do a case insensitive match and whether
     // the character class is negated or not.
     CharClass(Vec<(char, char)>, Flags),
 
@@ -48,7 +48,7 @@ pub enum Inst {
     EmptyBegin(Flags),
 
     // Matches the end of the string, consumes no characters.
-    // The flags indicate whether it matches if the proceding character
+    // The flags indicate whether it matches if the proceeding character
     // is a new line.
     EmptyEnd(Flags),
 

branches/try2/src/librustc/driver/mod.rs

@@ -189,7 +189,7 @@ fn describe_codegen_flags() {
     }
 }
 
-/// Process command line options. Emits messages as appropirate.If compilation
+/// Process command line options. Emits messages as appropriate. If compilation
 /// should continue, returns a getopts::Matches object parsed from args, otherwise
 /// returns None.
 pub fn handle_options(mut args: Vec<String>) -> Option<getopts::Matches> {

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

@@ -130,7 +130,9 @@ fn inject_crates_ref(sess: &Session, krate: ast::Crate) -> ast::Crate {
     fold.fold_crate(krate)
 }
 
-struct PreludeInjector<'a>;
+struct PreludeInjector<'a> {
+    sess: &'a Session,
+}
 
 
 impl<'a> fold::Folder for PreludeInjector<'a> {
@@ -221,7 +223,9 @@ impl<'a> fold::Folder for PreludeInjector<'a> {
     }
 }
 
-fn inject_prelude(_: &Session, krate: ast::Crate) -> ast::Crate {
-    let mut fold = PreludeInjector;
+fn inject_prelude(sess: &Session, krate: ast::Crate) -> ast::Crate {
+    let mut fold = PreludeInjector {
+        sess: sess,
+    };
     fold.fold_crate(krate)
 }

branches/try2/src/librustc/metadata/loader.rs

@@ -86,7 +86,7 @@ pub struct Library {
 }
 
 pub struct ArchiveMetadata {
-    _archive: ArchiveRO,
+    archive: ArchiveRO,
     // See comments in ArchiveMetadata::new for why this is static
     data: &'static [u8],
 }
@@ -487,7 +487,7 @@ impl ArchiveMetadata {
             unsafe { mem::transmute(data) }
         };
         Some(ArchiveMetadata {
-            _archive: ar,
+            archive: ar,
             data: data,
         })
     }

branches/try2/src/librustc/metadata/tyencode.rs

@@ -42,6 +42,8 @@ pub struct ctxt<'a> {
 // Extra parameters are for converting to/from def_ids in the string rep.
 // Whatever format you choose should not contain pipe characters.
 pub struct ty_abbrev {
+    pos: uint,
+    len: uint,
     s: String
 }
 
@@ -66,6 +68,8 @@ pub fn enc_ty(w: &mut MemWriter, cx: &ctxt, t: ty::t) {
     if abbrev_len < len {
         // I.e. it's actually an abbreviation.
         cx.abbrevs.borrow_mut().insert(t, ty_abbrev {
+            pos: pos as uint,
+            len: len as uint,
             s: format!("\\#{:x}:{:x}\\#", pos, len)
         });
     }

branches/try2/src/librustc/middle/borrowck/doc.rs

@@ -551,7 +551,7 @@ are computed based on the kind of borrow:
 The reasoning here is that a mutable borrow must be the only writer,
 therefore it prevents other writes (`MUTATE`), mutable borrows
 (`CLAIM`), and immutable borrows (`FREEZE`). An immutable borrow
-permits other immutable borrows but forbids writes and mutable borows.
+permits other immutable borrows but forbids writes and mutable borrows.
 Finally, a const borrow just wants to be sure that the value is not
 moved out from under it, so no actions are forbidden.
 

branches/try2/src/librustc/middle/borrowck/gather_loans/lifetime.rs

@@ -29,7 +29,7 @@ pub fn guarantee_lifetime(bccx: &BorrowckCtxt,
                           cause: euv::LoanCause,
                           cmt: mc::cmt,
                           loan_region: ty::Region,
-                          _: ty::BorrowKind)
+                          loan_kind: ty::BorrowKind)
                           -> Result<(),()> {
     debug!("guarantee_lifetime(cmt={}, loan_region={})",
            cmt.repr(bccx.tcx), loan_region.repr(bccx.tcx));
@@ -38,6 +38,7 @@ pub fn guarantee_lifetime(bccx: &BorrowckCtxt,
                                          span: span,
                                          cause: cause,
                                          loan_region: loan_region,
+                                         loan_kind: loan_kind,
                                          cmt_original: cmt.clone()};
     ctxt.check(&cmt, None)
 }
@@ -54,6 +55,7 @@ struct GuaranteeLifetimeContext<'a> {
     span: Span,
     cause: euv::LoanCause,
     loan_region: ty::Region,
+    loan_kind: ty::BorrowKind,
     cmt_original: mc::cmt
 }
 

branches/try2/src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -310,6 +310,7 @@ impl<'a> GatherLoanCtxt<'a> {
                 Loan {
                     index: self.all_loans.len(),
                     loan_path: loan_path,
+                    cmt: cmt,
                     kind: req_kind,
                     gen_scope: gen_scope,
                     kill_scope: kill_scope,
@@ -480,7 +481,8 @@ impl<'a> GatherLoanCtxt<'a> {
 /// This visitor walks static initializer's expressions and makes
 /// sure the loans being taken are sound.
 struct StaticInitializerCtxt<'a> {
-    bccx: &'a BorrowckCtxt<'a>
+    bccx: &'a BorrowckCtxt<'a>,
+    item_ub: ast::NodeId,
 }
 
 impl<'a> visit::Visitor<()> for StaticInitializerCtxt<'a> {
@@ -507,7 +509,8 @@ pub fn gather_loans_in_static_initializer(bccx: &mut BorrowckCtxt, expr: &ast::E
     debug!("gather_loans_in_static_initializer(expr={})", expr.repr(bccx.tcx));
 
     let mut sicx = StaticInitializerCtxt {
-        bccx: bccx
+        bccx: bccx,
+        item_ub: expr.id,
     };
 
     sicx.visit_expr(expr, ());

branches/try2/src/librustc/middle/borrowck/gather_loans/restrictions.rs

@@ -36,6 +36,7 @@ pub fn compute_restrictions(bccx: &BorrowckCtxt,
         bccx: bccx,
         span: span,
         cause: cause,
+        cmt_original: cmt.clone(),
         loan_region: loan_region,
     };
 
@@ -48,6 +49,7 @@ pub fn compute_restrictions(bccx: &BorrowckCtxt,
 struct RestrictionsContext<'a> {
     bccx: &'a BorrowckCtxt<'a>,
     span: Span,
+    cmt_original: mc::cmt,
     loan_region: ty::Region,
     cause: euv::LoanCause,
 }

branches/try2/src/librustc/middle/borrowck/mod.rs

@@ -180,6 +180,7 @@ pub enum PartialTotal {
 pub struct Loan {
     index: uint,
     loan_path: Rc<LoanPath>,
+    cmt: mc::cmt,
     kind: ty::BorrowKind,
     restrictions: Vec<Restriction>,
     gen_scope: ast::NodeId,