---

yaml
---
r: 59276
b: refs/heads/snap-stage3
c: 47050c4
h: refs/heads/master
v: v3

Author: Sodel-the-Vociferous

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 213f7b24ccd9a6833af7e1a329c5e7ffc8f9e3d2
+refs/heads/snap-stage3: 47050c499a7cc6823ce8ac94f9766dd7a5e61108
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libcore/to_bytes.rs

@@ -419,8 +419,7 @@ impl<A> IterBytes for *const A {
     }
 }
 
-
-trait ToBytes {
+pub trait ToBytes {
     fn to_bytes(&self, lsb0: bool) -> ~[u8];
 }
 

branches/snap-stage3/src/librustc/middle/ty.rs

@@ -1808,6 +1808,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)
@@ -1867,6 +1876,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};
 
@@ -2087,6 +2099,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;
     }
@@ -2162,6 +2178,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 {
@@ -2421,15 +2499,12 @@ pub fn type_is_enum(ty: t) -> bool {
 // constructors
 pub fn type_is_c_like_enum(cx: ctxt, ty: t) -> bool {
     match get(ty).sty {
-        ty_enum(did, _) => {
-            let variants = enum_variants(cx, did);
-            if variants.len() == 0 {
-                false
-            } else {
-                variants.all(|v| v.args.len() == 0)
-            }
-        }
-        _ => false
+      ty_enum(did, _) => {
+        let variants = enum_variants(cx, did);
+        let some_n_ary = vec::any(*variants, |v| vec::len(v.args) > 0u);
+        return !some_n_ary;
+      }
+      _ => return false
     }
 }