---

yaml
---
r: 129019
b: refs/heads/master
c: 2e5aea6
h: refs/heads/master
i:
  129017: ec8fd4b
  129015: 81a8c22
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: be8bd24e3190237469f74a426c9daa12c70d3de1
+refs/heads/master: 2e5aea65cd2594f19b9043d8df0e6461504cda9b
 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

@@ -2896,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/libcollections/priority_queue.rs

@@ -529,10 +529,9 @@ impl<'a, T> Iterator<&'a T> for Items<'a, T> {
 }
 
 impl<T: Ord> FromIterator<T> for PriorityQueue<T> {
-    fn from_iter<Iter: Iterator<T>>(iter: Iter) -> PriorityQueue<T> {
-        let mut q = PriorityQueue::new();
-        q.extend(iter);
-        q
+    fn from_iter<Iter: Iterator<T>>(mut iter: Iter) -> PriorityQueue<T> {
+        let vec: Vec<T> = iter.collect();
+        PriorityQueue::from_vec(vec)
     }
 }
 

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/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) => {

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

@@ -288,7 +288,7 @@ fn resolve_default_method_vtables(bcx: &Block,
 /// `Trait` so that a by-value self method can be called.
 pub fn trans_unboxing_shim(bcx: &Block,
                            llshimmedfn: ValueRef,
-                           method: &ty::Method,
+                           fty: &ty::BareFnTy,
                            method_id: ast::DefId,
                            substs: subst::Substs)
                            -> ValueRef {
@@ -297,29 +297,29 @@ pub fn trans_unboxing_shim(bcx: &Block,
     let tcx = bcx.tcx();
 
     // Transform the self type to `Box<self_type>`.
-    let self_type = *method.fty.sig.inputs.get(0);
+    let self_type = *fty.sig.inputs.get(0);
     let boxed_self_type = ty::mk_uniq(tcx, self_type);
     let boxed_function_type = ty::FnSig {
-        binder_id: method.fty.sig.binder_id,
-        inputs: method.fty.sig.inputs.iter().enumerate().map(|(i, typ)| {
+        binder_id: fty.sig.binder_id,
+        inputs: fty.sig.inputs.iter().enumerate().map(|(i, typ)| {
             if i == 0 {
                 boxed_self_type
             } else {
                 *typ
             }
         }).collect(),
-        output: method.fty.sig.output,
+        output: fty.sig.output,
         variadic: false,
     };
     let boxed_function_type = ty::BareFnTy {
-        fn_style: method.fty.fn_style,
-        abi: method.fty.abi,
+        fn_style: fty.fn_style,
+        abi: fty.abi,
         sig: boxed_function_type,
     };
     let boxed_function_type =
         ty::mk_bare_fn(tcx, boxed_function_type).subst(tcx, &substs);
     let function_type =
-        ty::mk_bare_fn(tcx, method.fty.clone()).subst(tcx, &substs);
+        ty::mk_bare_fn(tcx, (*fty).clone()).subst(tcx, &substs);
 
     let function_name = ty::with_path(tcx, method_id, |path| {
         link::mangle_internal_name_by_path_and_seq(path, "unboxing_shim")

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

@@ -201,7 +201,9 @@ impl param_substs {
 }
 
 fn param_substs_to_string(this: &param_substs, tcx: &ty::ctxt) -> String {
-    format!("param_substs({})", this.substs.repr(tcx))
+    format!("param_substs(substs={},vtables={})",
+            this.substs.repr(tcx),
+            this.vtables.repr(tcx))
 }
 
 impl Repr for param_substs {
@@ -859,8 +861,7 @@ pub fn find_vtable(tcx: &ty::ctxt,
     debug!("find_vtable(n_param={:?}, n_bound={}, ps={})",
            n_param, n_bound, ps.repr(tcx));
 
-    let param_bounds = ps.vtables.get(n_param.space,
-                                      n_param.index);
+    let param_bounds = ps.vtables.get(n_param.space, n_param.index);
     param_bounds.get(n_bound).clone()
 }