---

yaml
---
r: 129013
b: refs/heads/master
c: d0104d0
h: refs/heads/master
i:
  129011: 84a8eaa
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f59cfd9711e34d9152ea58409051985c362fc3ad
+refs/heads/master: d0104d04fdf5126bdc3f76eac93906f25a201ad3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
 refs/heads/try: 961753763fb87ddcbbccaec4ea87648608d19a58

trunk/src/doc/guide.md

@@ -1073,8 +1073,8 @@ destructuring `let`.
 ## Enums
 
 Finally, Rust has a "sum type", an **enum**. Enums are an incredibly useful
-feature of Rust, and are used throughout the standard library. Enums look
-like this:
+feature of Rust, and are used throughout the standard library. This is an enum
+that is provided by the Rust standard library:
 
 ```{rust}
 enum Ordering {
@@ -1084,9 +1084,8 @@ enum Ordering {
 }
 ```
 
-This is an enum that is provided by the Rust standard library. An `Ordering`
-can only be _one_ of `Less`, `Equal`, or `Greater` at any given time. Here's
-an example:
+An `Ordering` can only be _one_ of `Less`, `Equal`, or `Greater` at any given
+time. Here's an example:
 
 ```{rust}
 fn cmp(a: int, b: int) -> Ordering {
@@ -2897,9 +2896,11 @@ pub fn print_hello() {
 }
 ```
 
-When we include a module like this, we don't need to make the `mod` declaration,
-it's just understood. This helps prevent 'rightward drift': when you end up
-indenting so many times that your code is hard to read.
+When we include a module like this, we don't need to make the `mod` declaration
+in `hello.rs`, because it's already been declared in `lib.rs`. `hello.rs` just
+contains the body of the module which is defined (by the `pub mod hello`) in
+`lib.rs`.  This helps prevent 'rightward drift': when you end up indenting so
+many times that your code is hard to read.
 
 Finally, make a new directory, `src/goodbye`, and make a new file in it,
 `src/goodbye/mod.rs`:

trunk/src/libarena/lib.rs

@@ -563,7 +563,7 @@ mod tests {
 
     struct Noncopy {
         string: String,
-        array: Vec<int> ,
+        array: Vec<int>,
     }
 
     #[test]

trunk/src/libcollections/bitv.rs

@@ -2566,7 +2566,9 @@ mod tests {
         let mut r = rng();
         let mut bitv = 0 as uint;
         b.iter(|| {
-            bitv |= 1 << ((r.next_u32() as uint) % uint::BITS);
+            for _ in range(0u, 100) {
+                bitv |= 1 << ((r.next_u32() as uint) % uint::BITS);
+            }
             &bitv
         })
     }
@@ -2576,7 +2578,9 @@ mod tests {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(BENCH_BITS, false);
         b.iter(|| {
-            bitv.set((r.next_u32() as uint) % BENCH_BITS, true);
+            for _ in range(0u, 100) {
+                bitv.set((r.next_u32() as uint) % BENCH_BITS, true);
+            }
             &bitv
         })
     }
@@ -2586,7 +2590,9 @@ mod tests {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(uint::BITS, false);
         b.iter(|| {
-            bitv.set((r.next_u32() as uint) % uint::BITS, true);
+            for _ in range(0u, 100) {
+                bitv.set((r.next_u32() as uint) % uint::BITS, true);
+            }
             &bitv
         })
     }
@@ -2596,7 +2602,9 @@ mod tests {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
-            bitv.insert((r.next_u32() as uint) % uint::BITS);
+            for _ in range(0u, 100) {
+                bitv.insert((r.next_u32() as uint) % uint::BITS);
+            }
             &bitv
         })
     }
@@ -2606,7 +2614,9 @@ mod tests {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
-            bitv.insert((r.next_u32() as uint) % BENCH_BITS);
+            for _ in range(0u, 100) {
+                bitv.insert((r.next_u32() as uint) % BENCH_BITS);
+            }
             &bitv
         })
     }
@@ -2616,29 +2626,33 @@ mod tests {
         let mut b1 = Bitv::with_capacity(BENCH_BITS, false);
         let b2 = Bitv::with_capacity(BENCH_BITS, false);
         b.iter(|| {
-            b1.union(&b2);
+            b1.union(&b2)
         })
     }
 
     #[bench]
-    fn bench_btv_small_iter(b: &mut Bencher) {
+    fn bench_bitv_small_iter(b: &mut Bencher) {
         let bitv = Bitv::with_capacity(uint::BITS, false);
         b.iter(|| {
-            let mut _sum = 0;
-            for pres in bitv.iter() {
-                _sum += pres as uint;
+            let mut sum = 0;
+            for _ in range(0u, 10) {
+                for pres in bitv.iter() {
+                    sum += pres as uint;
+                }
             }
+            sum
         })
     }
 
     #[bench]
     fn bench_bitv_big_iter(b: &mut Bencher) {
         let bitv = Bitv::with_capacity(BENCH_BITS, false);
         b.iter(|| {
-            let mut _sum = 0;
+            let mut sum = 0;
             for pres in bitv.iter() {
-                _sum += pres as uint;
+                sum += pres as uint;
             }
+            sum
         })
     }
 
@@ -2647,10 +2661,11 @@ mod tests {
         let bitv = BitvSet::from_bitv(from_fn(BENCH_BITS,
                                               |idx| {idx % 3 == 0}));
         b.iter(|| {
-            let mut _sum = 0;
+            let mut sum = 0;
             for idx in bitv.iter() {
-                _sum += idx;
+                sum += idx;
             }
+            sum
         })
     }
 }

trunk/src/libcore/mem.rs

@@ -19,6 +19,16 @@ use ptr;
 
 pub use intrinsics::transmute;
 
+/// Moves a thing into the void.
+///
+/// The forget function will take ownership of the provided value but neglect
+/// to run any required cleanup or memory management operations on it.
+///
+/// This function is the unsafe version of the `drop` function because it does
+/// not run any destructors.
+#[stable]
+pub use intrinsics::forget;
+
 /// Returns the size of a type in bytes.
 #[inline]
 #[stable]
@@ -337,17 +347,6 @@ pub fn replace<T>(dest: &mut T, mut src: T) -> T {
 #[stable]
 pub fn drop<T>(_x: T) { }
 
-/// Moves a thing into the void.
-///
-/// The forget function will take ownership of the provided value but neglect
-/// to run any required cleanup or memory management operations on it.
-///
-/// This function is the unsafe version of the `drop` function because it does
-/// not run any destructors.
-#[inline]
-#[stable]
-pub unsafe fn forget<T>(thing: T) { intrinsics::forget(thing) }
-
 /// Interprets `src` as `&U`, and then reads `src` without moving the contained
 /// value.
 ///

trunk/src/libgetopts/lib.rs

@@ -571,7 +571,6 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                 }
             } else {
                 let mut j = 1;
-                let mut last_valid_opt_id = None;
                 names = Vec::new();
                 while j < curlen {
                     let range = cur.as_slice().char_range_at(j);
@@ -584,27 +583,24 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                        interpreted correctly
                     */
 
-                    match find_opt(opts.as_slice(), opt.clone()) {
-                      Some(id) => last_valid_opt_id = Some(id),
-                      None => {
-                        let arg_follows =
-                            last_valid_opt_id.is_some() &&
-                            match opts[last_valid_opt_id.unwrap()]
-                              .hasarg {
-
-                              Yes | Maybe => true,
-                              No => false
-                            };
-                        if arg_follows && j < curlen {
-                            i_arg = Some(cur.as_slice()
-                                            .slice(j, curlen).to_string());
-                            break;
-                        } else {
-                            last_valid_opt_id = None;
-                        }
-                      }
-                    }
+                    let opt_id = match find_opt(opts.as_slice(), opt.clone()) {
+                      Some(id) => id,
+                      None => return Err(UnrecognizedOption(opt.to_string()))
+                    };
+
                     names.push(opt);
+
+                    let arg_follows = match opts[opt_id].hasarg {
+                        Yes | Maybe => true,
+                        No => false
+                    };
+
+                    if arg_follows && range.next < curlen {
+                        i_arg = Some(cur.as_slice()
+                                        .slice(range.next, curlen).to_string());
+                        break;
+                    }
+
                     j = range.next;
                 }
             }
@@ -617,7 +613,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                 };
                 match opts[optid].hasarg {
                   No => {
-                    if !i_arg.is_none() {
+                    if name_pos == names.len() && !i_arg.is_none() {
                         return Err(UnexpectedArgument(nm.to_string()));
                     }
                     vals.get_mut(optid).push(Given);
@@ -1441,6 +1437,21 @@ mod tests {
 
     }
 
+    #[test]
+    fn test_nospace_conflict() {
+        let args = vec!("-vvLverbose".to_string(), "-v".to_string() );
+        let opts = vec!(optmulti("L", "", "library directory", "LIB"),
+                     optflagmulti("v", "verbose", "Verbose"));
+        let matches = &match getopts(args.as_slice(), opts.as_slice()) {
+          result::Ok(m) => m,
+          result::Err(e) => fail!( "{}", e )
+        };
+        assert!(matches.opts_present(["L".to_string()]));
+        assert_eq!(matches.opts_str(["L".to_string()]).unwrap(), "verbose".to_string());
+        assert!(matches.opts_present(["v".to_string()]));
+        assert_eq!(3, matches.opt_count("v"));
+    }
+
     #[test]
     fn test_long_to_short() {
         let mut short = Opt {

trunk/src/librustc/middle/resolve_lifetime.rs

@@ -206,7 +206,8 @@ impl<'a> LifetimeContext<'a> {
 
         self.check_lifetime_names(&generics.lifetimes);
 
-        let referenced_idents = free_lifetimes(&generics.ty_params);
+        let referenced_idents = free_lifetimes(&generics.ty_params,
+                                               &generics.where_clause);
         debug!("pushing fn scope id={} due to fn item/method\
                referenced_idents={:?}",
                n,
@@ -403,7 +404,8 @@ fn search_lifetimes(lifetimes: &Vec<ast::LifetimeDef>,
 ///////////////////////////////////////////////////////////////////////////
 
 pub fn early_bound_lifetimes<'a>(generics: &'a ast::Generics) -> Vec<ast::LifetimeDef> {
-    let referenced_idents = free_lifetimes(&generics.ty_params);
+    let referenced_idents = free_lifetimes(&generics.ty_params,
+                                           &generics.where_clause);
     if referenced_idents.is_empty() {
         return Vec::new();
     }
@@ -414,7 +416,9 @@ pub fn early_bound_lifetimes<'a>(generics: &'a ast::Generics) -> Vec<ast::Lifeti
         .collect()
 }
 
-pub fn free_lifetimes(ty_params: &OwnedSlice<ast::TyParam>) -> Vec<ast::Name> {
+pub fn free_lifetimes(ty_params: &OwnedSlice<ast::TyParam>,
+                      where_clause: &ast::WhereClause)
+                      -> Vec<ast::Name> {
     /*!
      * Gathers up and returns the names of any lifetimes that appear
      * free in `ty_params`. Of course, right now, all lifetimes appear
@@ -426,6 +430,9 @@ pub fn free_lifetimes(ty_params: &OwnedSlice<ast::TyParam>) -> Vec<ast::Name> {
     for ty_param in ty_params.iter() {
         visit::walk_ty_param_bounds(&mut collector, &ty_param.bounds, ());
     }
+    for predicate in where_clause.predicates.iter() {
+        visit::walk_ty_param_bounds(&mut collector, &predicate.bounds, ());
+    }
     return collector.names;
 
     struct FreeLifetimeCollector {

trunk/src/librustc/middle/trans/base.rs

@@ -2240,26 +2240,44 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t)
         ty::ty_bare_fn(ref f) => (f.sig.clone(), f.abi, false),
         ty::ty_unboxed_closure(closure_did, _) => {
             let unboxed_closures = ccx.tcx.unboxed_closures.borrow();
-            let function_type = unboxed_closures.get(&closure_did)
-                                                .closure_type
-                                                .clone();
+            let ref function_type = unboxed_closures.get(&closure_did)
+                                                    .closure_type;
+
             (function_type.sig.clone(), RustCall, true)
         }
-        _ => fail!("expected closure or function.")
+        _ => ccx.sess().bug("expected closure or function.")
     };
 
+
     // Since index 0 is the return value of the llvm func, we start
     // at either 1 or 2 depending on whether there's an env slot or not
     let mut first_arg_offset = if has_env { 2 } else { 1 };
     let mut attrs = llvm::AttrBuilder::new();
     let ret_ty = fn_sig.output;
 
-    // These have an odd calling convention, so we skip them for now.
-    //
-    // FIXME(pcwalton): We don't have to skip them; just untuple the result.
-    if abi == RustCall {
-        return attrs;
-    }
+    // These have an odd calling convention, so we need to manually
+    // unpack the input ty's
+    let input_tys = match ty::get(fn_ty).sty {
+        ty::ty_unboxed_closure(_, _) => {
+            assert!(abi == RustCall);
+
+            match ty::get(fn_sig.inputs[0]).sty {
+                ty::ty_nil => Vec::new(),
+                ty::ty_tup(ref inputs) => inputs.clone(),
+                _ => ccx.sess().bug("expected tuple'd inputs")
+            }
+        },
+        ty::ty_bare_fn(_) if abi == RustCall => {
+            let inputs = vec![fn_sig.inputs[0]];
+
+            match ty::get(fn_sig.inputs[1]).sty {
+                ty::ty_nil => inputs,
+                ty::ty_tup(ref t_in) => inputs.append(t_in.as_slice()),
+                _ => ccx.sess().bug("expected tuple'd inputs")
+            }
+        }
+        _ => fn_sig.inputs.clone()
+    };
 
     // A function pointer is called without the declaration
     // available, so we have to apply any attributes with ABI
@@ -2315,7 +2333,7 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t)
         }
     }
 
-    for (idx, &t) in fn_sig.inputs.iter().enumerate().map(|(i, v)| (i + first_arg_offset, v)) {
+    for (idx, &t) in input_tys.iter().enumerate().map(|(i, v)| (i + first_arg_offset, v)) {
         match ty::get(t).sty {
             // this needs to be first to prevent fat pointers from falling through
             _ if !type_is_immediate(ccx, t) => {