---

yaml
---
r: 59892
b: refs/heads/master
c: 326d966
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 6883814a84d584e1fd65a1d40229807ff3d34efb
+refs/heads/master: 326d9661b7cdeb0e429468b378fb2af716a3a955
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589

trunk/src/libcore/hashmap.rs

@@ -833,7 +833,7 @@ pub impl <T:Hash + Eq> HashSet<T> {
     }
 }
 
-#[test]
+#[cfg(test)]
 mod test_map {
     use container::{Container, Map, Set};
     use option::{None, Some};
@@ -1009,7 +1009,7 @@ mod test_map {
     }
 }
 
-#[test]
+#[cfg(test)]
 mod test_set {
     use super::*;
     use container::{Container, Map, Set};

trunk/src/libcore/iterator.rs

@@ -29,7 +29,7 @@ pub trait Iterator<A> {
 ///
 /// In the future these will be default methods instead of a utility trait.
 pub trait IteratorUtil<A> {
-    fn chain(self, other: Self) -> ChainIterator<Self>;
+    fn chain<U: Iterator<A>>(self, other: U) -> ChainIterator<Self, U>;
     fn zip<B, U: Iterator<B>>(self, other: U) -> ZipIterator<Self, U>;
     // FIXME: #5898: should be called map
     fn transform<'r, B>(self, f: &'r fn(A) -> B) -> MapIterator<'r, A, B, Self>;
@@ -50,7 +50,7 @@ pub trait IteratorUtil<A> {
 /// In the future these will be default methods instead of a utility trait.
 impl<A, T: Iterator<A>> IteratorUtil<A> for T {
     #[inline(always)]
-    fn chain(self, other: T) -> ChainIterator<T> {
+    fn chain<U: Iterator<A>>(self, other: U) -> ChainIterator<T, U> {
         ChainIterator{a: self, b: other, flag: false}
     }
 
@@ -115,13 +115,13 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
     }
 }
 
-pub struct ChainIterator<T> {
+pub struct ChainIterator<T, U> {
     priv a: T,
-    priv b: T,
+    priv b: U,
     priv flag: bool
 }
 
-impl<A, T: Iterator<A>> Iterator<A> for ChainIterator<T> {
+impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for ChainIterator<T, U> {
     #[inline]
     fn next(&mut self) -> Option<A> {
         if self.flag {
@@ -385,7 +385,7 @@ mod tests {
     #[test]
     fn test_iterator_chain() {
         let xs = [0u, 1, 2, 3, 4, 5];
-        let ys = [30, 40, 50, 60];
+        let ys = [30u, 40, 50, 60];
         let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
         let mut it = xs.iter().chain(ys.iter());
         let mut i = 0;
@@ -394,6 +394,15 @@ mod tests {
             i += 1;
         }
         assert_eq!(i, expected.len());
+
+        let ys = Counter::new(30u, 10).take(4);
+        let mut it = xs.iter().transform(|&x| x).chain(ys);
+        let mut i = 0;
+        for it.advance |x: uint| {
+            assert_eq!(x, expected[i]);
+            i += 1;
+        }
+        assert_eq!(i, expected.len());
     }
 
     #[test]

trunk/src/libcore/repr.rs

@@ -673,7 +673,7 @@ pub fn write_repr<T>(writer: @Writer, object: &T) {
     }
 }
 
-#[test]
+#[cfg(test)]
 struct P {a: int, b: float}
 
 #[test]

trunk/src/libcore/task/mod.rs

@@ -797,7 +797,7 @@ fn test_run_basic() {
     po.recv();
 }
 
-#[test]
+#[cfg(test)]
 struct Wrapper {
     mut f: Option<Chan<()>>
 }

trunk/src/librustc/front/test.rs

@@ -141,7 +141,7 @@ fn fold_item(cx: @mut TestCtxt, i: @ast::item, fld: @fold::ast_fold)
     debug!("current path: %s",
            ast_util::path_name_i(copy cx.path, cx.sess.parse_sess.interner));
 
-    if is_test_fn(i) || is_bench_fn(i) {
+    if is_test_fn(cx, i) || is_bench_fn(i) {
         match i.node {
           ast::item_fn(_, purity, _, _, _) if purity == ast::unsafe_fn => {
             let sess = cx.sess;
@@ -169,7 +169,7 @@ fn fold_item(cx: @mut TestCtxt, i: @ast::item, fld: @fold::ast_fold)
     return res;
 }
 
-fn is_test_fn(i: @ast::item) -> bool {
+fn is_test_fn(cx: @mut TestCtxt, i: @ast::item) -> bool {
     let has_test_attr = !attr::find_attrs_by_name(i.attrs,
                                                   ~"test").is_empty();
 
@@ -188,6 +188,13 @@ fn is_test_fn(i: @ast::item) -> bool {
         }
     }
 
+    if has_test_attr && !has_test_signature(i) {
+        let sess = cx.sess;
+        sess.span_err(
+            i.span,
+            ~"functions used as tests must have signature fn() -> ()."
+        );
+    }
     return has_test_attr && has_test_signature(i);
 }
 

trunk/src/librustc/middle/ty.rs

@@ -1818,6 +1818,15 @@ pub impl TypeContents {
         if cx.vecs_implicitly_copyable {base} else {base + TC_OWNED_VEC}
     }
 
+    fn is_safe_for_default_mode(&self, cx: ctxt) -> bool {
+        !self.intersects(TypeContents::nondefault_mode(cx))
+    }
+
+    fn nondefault_mode(cx: ctxt) -> TypeContents {
+        let tc = TypeContents::nonimplicitly_copyable(cx);
+        tc + TC_BIG + TC_OWNED_VEC // disregard cx.vecs_implicitly_copyable
+    }
+
     fn needs_drop(&self, cx: ctxt) -> bool {
         let tc = TC_MANAGED + TC_DTOR + TypeContents::owned(cx);
         self.intersects(tc)
@@ -1877,6 +1886,9 @@ static TC_MUTABLE: TypeContents =          TypeContents{bits:0b000010000000};
 /// Mutable content, whether owned or by ref
 static TC_ONCE_CLOSURE: TypeContents =     TypeContents{bits:0b000100000000};
 
+/// Something we estimate to be "big"
+static TC_BIG: TypeContents =              TypeContents{bits:0b001000000000};
+
 /// An enum with no variants.
 static TC_EMPTY_ENUM: TypeContents =       TypeContents{bits:0b010000000000};
 
@@ -2097,6 +2109,10 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
             }
         };
 
+        if type_size(cx, ty) > 4 {
+            result = result + TC_BIG;
+        }
+
         cache.insert(ty_id, result);
         return result;
     }
@@ -2172,6 +2188,68 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
         debug!("result = %s", r.to_str());
         return r;
     }
+
+    /// gives a rough estimate of how much space it takes to represent
+    /// an instance of `ty`.  Used for the mode transition.
+    fn type_size(cx: ctxt, ty: t) -> uint {
+        match get(ty).sty {
+          ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
+          ty_ptr(_) | ty_box(_) | ty_uniq(_) | ty_estr(vstore_uniq) |
+          ty_trait(*) | ty_rptr(*) | ty_evec(_, vstore_uniq) |
+          ty_evec(_, vstore_box) | ty_estr(vstore_box) => {
+            1
+          }
+
+          ty_evec(_, vstore_slice(_)) |
+          ty_estr(vstore_slice(_)) |
+          ty_bare_fn(*) |
+          ty_closure(*) => {
+            2
+          }
+
+          ty_evec(t, vstore_fixed(n)) => {
+            type_size(cx, t.ty) * n
+          }
+
+          ty_estr(vstore_fixed(n)) => {
+            n
+          }
+
+          ty_struct(did, ref substs) => {
+            let flds = struct_fields(cx, did, substs);
+            flds.foldl(0, |s, f| *s + type_size(cx, f.mt.ty))
+          }
+
+          ty_tup(ref tys) => {
+            tys.foldl(0, |s, t| *s + type_size(cx, *t))
+          }
+
+          ty_enum(did, ref substs) => {
+            let variants = substd_enum_variants(cx, did, substs);
+            variants.foldl( // find max size of any variant
+                0,
+                |m, v| uint::max(
+                    *m,
+                    // find size of this variant:
+                    v.args.foldl(0, |s, a| *s + type_size(cx, *a))))
+          }
+
+          ty_param(_) | ty_self(_) => {
+            1
+          }
+
+          ty_infer(_) => {
+            cx.sess.bug(~"Asked to compute kind of a type variable");
+          }
+          ty_type => 1,
+          ty_opaque_closure_ptr(_) => 1,
+          ty_opaque_box => 1,
+          ty_unboxed_vec(_) => 10,
+          ty_err => {
+            cx.sess.bug(~"Asked to compute kind of fictitious type");
+          }
+        }
+    }
 }
 
 pub fn type_moves_by_default(cx: ctxt, ty: t) -> bool {

trunk/src/libstd/cmp.rs

@@ -64,7 +64,7 @@ fn test_fuzzy_eq_eps() {
     assert!(!(&1.5f).fuzzy_eq_eps(&0.9, &0.5));
 }
 
-#[test]
+#[cfg(test)]
 mod test_complex{
     use cmp::*;
 

trunk/src/libstd/deque.rs

@@ -353,7 +353,7 @@ mod tests {
         assert!(*deq.get(3) == d);
     }
 
-    #[test]
+    #[cfg(test)]
     fn test_parameterized<T:Copy + Eq + Durable>(a: T, b: T, c: T, d: T) {
         let mut deq = Deque::new();
         assert!(deq.len() == 0);

trunk/src/libsyntax/parse/mod.rs

@@ -418,7 +418,7 @@ mod test {
         new_parser_from_source_str(ps,~[],~"bogofile",source_str)
     }
 
-    #[test] fn to_json_str<E : Encodable<std::json::Encoder>>(val: @E) -> ~str {
+    #[cfg(test)] fn to_json_str<E : Encodable<std::json::Encoder>>(val: @E) -> ~str {
         do io::with_str_writer |writer| {
             val.encode(~std::json::Encoder(writer));
         }

trunk/src/rt/rust_task.h

@@ -175,6 +175,10 @@
 #define RED_ZONE_SIZE RZ_MAC_32
 #endif
 
+#ifndef RED_ZONE_SIZE
+# error "Red zone not defined for this platform"
+#endif
+
 struct frame_glue_fns {
     uintptr_t mark_glue_off;
     uintptr_t drop_glue_off;