---

yaml
---
r: 129228
b: refs/heads/try
c: be8bd24
h: refs/heads/master
v: v3

Author: retep998

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 1cad4089ba0dc46248da2459af904e38243f294d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 75396b2a06a9372ed4ddcc3e5bcf56d18f1973ae
+refs/heads/try: be8bd24e3190237469f74a426c9daa12c70d3de1
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/configure

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

branches/try/src/doc/guide.md

@@ -2896,11 +2896,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`:

branches/try/src/libarena/lib.rs

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

branches/try/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
         })
     }
 }

branches/try/src/libcollections/priority_queue.rs

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

branches/try/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.
 ///

branches/try/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 {

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

branches/try/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,
-                           fty: &ty::BareFnTy,
+                           method: &ty::Method,
                            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 = *fty.sig.inputs.get(0);
+    let self_type = *method.fty.sig.inputs.get(0);
     let boxed_self_type = ty::mk_uniq(tcx, self_type);
     let boxed_function_type = ty::FnSig {
-        binder_id: fty.sig.binder_id,
-        inputs: fty.sig.inputs.iter().enumerate().map(|(i, typ)| {
+        binder_id: method.fty.sig.binder_id,
+        inputs: method.fty.sig.inputs.iter().enumerate().map(|(i, typ)| {
             if i == 0 {
                 boxed_self_type
             } else {
                 *typ
             }
         }).collect(),
-        output: fty.sig.output,
+        output: method.fty.sig.output,
         variadic: false,
     };
     let boxed_function_type = ty::BareFnTy {
-        fn_style: fty.fn_style,
-        abi: fty.abi,
+        fn_style: method.fty.fn_style,
+        abi: method.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, (*fty).clone()).subst(tcx, &substs);
+        ty::mk_bare_fn(tcx, method.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")

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

@@ -201,9 +201,7 @@ impl param_substs {
 }
 
 fn param_substs_to_string(this: &param_substs, tcx: &ty::ctxt) -> String {
-    format!("param_substs(substs={},vtables={})",
-            this.substs.repr(tcx),
-            this.vtables.repr(tcx))
+    format!("param_substs({})", this.substs.repr(tcx))
 }
 
 impl Repr for param_substs {
@@ -861,7 +859,8 @@ 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()
 }