---

yaml
---
r: 129014
b: refs/heads/master
c: 70ea0bb
h: refs/heads/master
v: v3

Author: jauhien

[refs]

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

trunk/configure

@@ -635,7 +635,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-        (3.[2-5]*)
+        (3.[2-6]*)
             msg "found ok version of LLVM: $LLVM_VERSION"
             ;;
         (*)

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. This is an enum
-that is provided by the Rust standard library:
+feature of Rust, and are used throughout the standard library. Enums look
+like this:
 
 ```{rust}
 enum Ordering {
@@ -1084,8 +1084,9 @@ enum Ordering {
 }
 ```
 
-An `Ordering` can only be _one_ of `Less`, `Equal`, or `Greater` at any given
-time. Here's an example:
+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:
 
 ```{rust}
 fn cmp(a: int, b: int) -> Ordering {
@@ -2896,11 +2897,9 @@ pub fn print_hello() {
 }
 ```
 
-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.
+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.
 
 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,9 +2566,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = 0 as uint;
         b.iter(|| {
-            for _ in range(0u, 100) {
-                bitv |= 1 << ((r.next_u32() as uint) % uint::BITS);
-            }
+            bitv |= 1 << ((r.next_u32() as uint) % uint::BITS);
             &bitv
         })
     }
@@ -2578,9 +2576,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(BENCH_BITS, false);
         b.iter(|| {
-            for _ in range(0u, 100) {
-                bitv.set((r.next_u32() as uint) % BENCH_BITS, true);
-            }
+            bitv.set((r.next_u32() as uint) % BENCH_BITS, true);
             &bitv
         })
     }
@@ -2590,9 +2586,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(uint::BITS, false);
         b.iter(|| {
-            for _ in range(0u, 100) {
-                bitv.set((r.next_u32() as uint) % uint::BITS, true);
-            }
+            bitv.set((r.next_u32() as uint) % uint::BITS, true);
             &bitv
         })
     }
@@ -2602,9 +2596,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
-            for _ in range(0u, 100) {
-                bitv.insert((r.next_u32() as uint) % uint::BITS);
-            }
+            bitv.insert((r.next_u32() as uint) % uint::BITS);
             &bitv
         })
     }
@@ -2614,9 +2606,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
-            for _ in range(0u, 100) {
-                bitv.insert((r.next_u32() as uint) % BENCH_BITS);
-            }
+            bitv.insert((r.next_u32() as uint) % BENCH_BITS);
             &bitv
         })
     }
@@ -2626,33 +2616,29 @@ 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_bitv_small_iter(b: &mut Bencher) {
+    fn bench_btv_small_iter(b: &mut Bencher) {
         let bitv = Bitv::with_capacity(uint::BITS, false);
         b.iter(|| {
-            let mut sum = 0;
-            for _ in range(0u, 10) {
-                for pres in bitv.iter() {
-                    sum += pres as uint;
-                }
+            let mut _sum = 0;
+            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
         })
     }
 
@@ -2661,11 +2647,10 @@ 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,16 +19,6 @@ 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]
@@ -347,6 +337,17 @@ 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,6 +571,7 @@ 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);
@@ -583,24 +584,27 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                        interpreted correctly
                     */
 
-                    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;
+                    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;
+                        }
+                      }
                     }
-
+                    names.push(opt);
                     j = range.next;
                 }
             }
@@ -613,7 +617,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                 };
                 match opts[optid].hasarg {
                   No => {
-                    if name_pos == names.len() && !i_arg.is_none() {
+                    if !i_arg.is_none() {
                         return Err(UnexpectedArgument(nm.to_string()));
                     }
                     vals.get_mut(optid).push(Given);
@@ -1437,21 +1441,6 @@ 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,8 +206,7 @@ impl<'a> LifetimeContext<'a> {
 
         self.check_lifetime_names(&generics.lifetimes);
 
-        let referenced_idents = free_lifetimes(&generics.ty_params,
-                                               &generics.where_clause);
+        let referenced_idents = free_lifetimes(&generics.ty_params);
         debug!("pushing fn scope id={} due to fn item/method\
                referenced_idents={:?}",
                n,
@@ -404,8 +403,7 @@ 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,
-                                           &generics.where_clause);
+    let referenced_idents = free_lifetimes(&generics.ty_params);
     if referenced_idents.is_empty() {
         return Vec::new();
     }
@@ -416,9 +414,7 @@ pub fn early_bound_lifetimes<'a>(generics: &'a ast::Generics) -> Vec<ast::Lifeti
         .collect()
 }
 
-pub fn free_lifetimes(ty_params: &OwnedSlice<ast::TyParam>,
-                      where_clause: &ast::WhereClause)
-                      -> Vec<ast::Name> {
+pub fn free_lifetimes(ty_params: &OwnedSlice<ast::TyParam>) -> 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
@@ -430,9 +426,6 @@ pub fn free_lifetimes(ty_params: &OwnedSlice<ast::TyParam>,
     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,44 +2240,26 @@ 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 ref function_type = unboxed_closures.get(&closure_did)
-                                                    .closure_type;
-
+            let function_type = unboxed_closures.get(&closure_did)
+                                                .closure_type
+                                                .clone();
             (function_type.sig.clone(), RustCall, true)
         }
-        _ => ccx.sess().bug("expected closure or function.")
+        _ => fail!("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 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()
-    };
+    // 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;
+    }
 
     // A function pointer is called without the declaration
     // available, so we have to apply any attributes with ABI
@@ -2333,7 +2315,7 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t)
         }
     }
 
-    for (idx, &t) in input_tys.iter().enumerate().map(|(i, v)| (i + first_arg_offset, v)) {
+    for (idx, &t) in fn_sig.inputs.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) => {