---

yaml
---
r: 82779
b: refs/heads/auto
c: 11b7109
h: refs/heads/master
i:
  82777: 5cd5f32
  82775: 89113c2
v: v3

Author: thestinger

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 7ddcd2a745ab70b3d32249e35b753117b1312d15
+refs/heads/auto: 11b7109b7b3b1ad69d7137d1509fac7a8edda92e
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/tests.mk

@@ -261,15 +261,6 @@ tidy:
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
 		$(Q)echo $(ALL_HS) \
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
-		$(Q)find $(S)src -type f -perm +111 \
-		    -not -name '*.rs' -and -not -name '*.py' \
-		    -and -not -name '*.sh' \
-		| grep '^$(S)src/llvm' -v \
-		| grep '^$(S)src/libuv' -v \
-		| grep '^$(S)src/gyp' -v \
-		| grep '^$(S)src/etc' -v \
-		| grep '^$(S)src/rt/jemalloc' -v \
-		| xargs $(CFG_PYTHON) $(S)src/etc/check-binaries.py
 
 endif
 

branches/auto/src/etc/check-binaries.py

@@ -1121,13 +1121,13 @@ pub fn do_spill_noroot(cx: @mut Block, v: ValueRef) -> ValueRef {
 
 pub fn spill_if_immediate(cx: @mut Block, v: ValueRef, t: ty::t) -> ValueRef {
     let _icx = push_ctxt("spill_if_immediate");
-    if ty::type_is_immediate(cx.tcx(), t) { return do_spill(cx, v, t); }
+    if type_is_immediate(cx.tcx(), t) { return do_spill(cx, v, t); }
     return v;
 }
 
 pub fn load_if_immediate(cx: @mut Block, v: ValueRef, t: ty::t) -> ValueRef {
     let _icx = push_ctxt("load_if_immediate");
-    if ty::type_is_immediate(cx.tcx(), t) { return Load(cx, v); }
+    if type_is_immediate(cx.tcx(), t) { return Load(cx, v); }
     return v;
 }
 

branches/auto/src/librustc/middle/trans/base.rs

@@ -15,7 +15,7 @@ use driver::session;
 use driver::session::Session;
 use lib::llvm::{ValueRef, BasicBlockRef, BuilderRef};
 use lib::llvm::{True, False, Bool};
-use lib::llvm::{llvm};
+use lib::llvm::llvm;
 use lib;
 use middle::lang_items::LangItem;
 use middle::trans::base;
@@ -28,24 +28,43 @@ use middle::ty::substs;
 use middle::ty;
 use middle::typeck;
 use middle::borrowck::root_map_key;
-use util::ppaux::{Repr};
+use util::ppaux::Repr;
 
 use middle::trans::type_::Type;
 
 use std::c_str::ToCStr;
 use std::cast::transmute;
 use std::cast;
-use std::hashmap::{HashMap};
+use std::hashmap::HashMap;
 use std::libc::{c_uint, c_longlong, c_ulonglong, c_char};
 use std::vec;
-use syntax::ast::{Name,Ident};
+use syntax::ast::{Name, Ident};
 use syntax::ast_map::{path, path_elt, path_pretty_name};
 use syntax::codemap::Span;
 use syntax::parse::token;
 use syntax::{ast, ast_map};
 
 pub use middle::trans::context::CrateContext;
 
+fn type_is_newtype_immediate(cx: ty::ctxt, ty: ty::t) -> bool {
+    match ty::get(ty).sty {
+        ty::ty_struct(def_id, ref substs) => {
+            let fields = ty::struct_fields(cx, def_id, substs);
+            fields.len() == 1 &&
+                fields[0].ident.name == token::special_idents::unnamed_field.name &&
+                type_is_immediate(cx, fields[0].mt.ty)
+        }
+        _ => false
+    }
+}
+
+pub fn type_is_immediate(cx: ty::ctxt, ty: ty::t) -> bool {
+    ty::type_is_scalar(ty) || ty::type_is_boxed(ty) ||
+        ty::type_is_unique(ty) || ty::type_is_region_ptr(ty) ||
+        type_is_newtype_immediate(cx, ty) ||
+        ty::type_is_simd(cx, ty)
+}
+
 pub fn gensym_name(name: &str) -> (Ident, path_elt) {
     let name = token::gensym(name);
     let ident = Ident::new(name);

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

@@ -197,7 +197,7 @@ pub fn appropriate_mode(tcx: ty::ctxt, ty: ty::t) -> DatumMode {
 
     if ty::type_is_voidish(ty) {
         ByValue
-    } else if ty::type_is_immediate(tcx, ty) {
+    } else if type_is_immediate(tcx, ty) {
         ByValue
     } else {
         ByRef(RevokeClean)
@@ -667,7 +667,7 @@ impl Datum {
                     ByValue => {
                         // Actually, this case cannot happen right
                         // now, because enums are never immediate.
-                        assert!(ty::type_is_immediate(bcx.tcx(), ty));
+                        assert!(type_is_immediate(bcx.tcx(), ty));
                         (Some(Datum {ty: ty, ..*self}), bcx)
                     }
                 };
@@ -699,7 +699,7 @@ impl Datum {
                         )
                     }
                     ByValue => {
-                        assert!(ty::type_is_immediate(bcx.tcx(), ty));
+                        assert!(type_is_immediate(bcx.tcx(), ty));
                         (
                             Some(Datum {
                                 val: ExtractValue(bcx, self.val, 0),

branches/auto/src/librustc/middle/trans/datum.rs

@@ -278,7 +278,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
         "uninit" => {
             // Do nothing, this is effectively a no-op
             let retty = substs.tys[0];
-            if ty::type_is_immediate(ccx.tcx, retty) && !ty::type_is_nil(retty) {
+            if type_is_immediate(ccx.tcx, retty) && !ty::type_is_nil(retty) {
                 unsafe {
                     Ret(bcx, lib::llvm::llvm::LLVMGetUndef(type_of(ccx, retty).to_ref()));
                 }
@@ -316,7 +316,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
 
             if !ty::type_is_voidish(out_type) {
                 let llsrcval = get_param(decl, first_real_arg);
-                if ty::type_is_immediate(ccx.tcx, in_type) {
+                if type_is_immediate(ccx.tcx, in_type) {
                     match fcx.llretptr {
                         Some(llretptr) => {
                             Store(bcx, llsrcval, PointerCast(bcx, llretptr, llintype.ptr_to()));
@@ -335,7 +335,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
                             }
                         }
                     }
-                } else if ty::type_is_immediate(ccx.tcx, out_type) {
+                } else if type_is_immediate(ccx.tcx, out_type) {
                     let llsrcptr = PointerCast(bcx, llsrcval, llouttype.ptr_to());
                     let ll_load = Load(bcx, llsrcptr);
                     Ret(bcx, ll_load);

branches/auto/src/librustc/middle/trans/intrinsic.rs

@@ -21,11 +21,11 @@ use syntax::ast;
 use syntax::opt_vec;
 
 pub fn arg_is_indirect(ccx: &CrateContext, arg_ty: ty::t) -> bool {
-    !ty::type_is_immediate(ccx.tcx, arg_ty)
+    !type_is_immediate(ccx.tcx, arg_ty)
 }
 
 pub fn return_uses_outptr(tcx: ty::ctxt, ty: ty::t) -> bool {
-    !ty::type_is_immediate(tcx, ty)
+    !type_is_immediate(tcx, ty)
 }
 
 pub fn type_of_explicit_arg(ccx: &mut CrateContext, arg_ty: ty::t) -> Type {

branches/auto/src/librustc/middle/trans/type_of.rs

@@ -1752,25 +1752,6 @@ pub fn type_is_scalar(ty: t) -> bool {
     }
 }
 
-fn type_is_newtype_immediate(cx: ctxt, ty: t) -> bool {
-    match get(ty).sty {
-        ty_struct(def_id, ref substs) => {
-            let fields = struct_fields(cx, def_id, substs);
-            fields.len() == 1 &&
-                fields[0].ident.name == token::special_idents::unnamed_field.name &&
-                type_is_immediate(cx, fields[0].mt.ty)
-        }
-        _ => false
-    }
-}
-
-pub fn type_is_immediate(cx: ctxt, ty: t) -> bool {
-    return type_is_scalar(ty) || type_is_boxed(ty) ||
-        type_is_unique(ty) || type_is_region_ptr(ty) ||
-        type_is_newtype_immediate(cx, ty) ||
-        type_is_simd(cx, ty);
-}
-
 pub fn type_needs_drop(cx: ctxt, ty: t) -> bool {
     type_contents(cx, ty).needs_drop(cx)
 }
@@ -2538,6 +2519,13 @@ pub fn type_structurally_contains_uniques(cx: ctxt, ty: t) -> bool {
     });
 }
 
+pub fn type_is_trait(ty: t) -> bool {
+    match get(ty).sty {
+        ty_trait(*) => true,
+        _ => false
+    }
+}
+
 pub fn type_is_integral(ty: t) -> bool {
     match get(ty).sty {
       ty_infer(IntVar(_)) | ty_int(_) | ty_uint(_) => true,
@@ -3289,10 +3277,10 @@ pub fn expr_kind(tcx: ctxt,
         ast::ExprCast(*) => {
             match tcx.node_types.find(&(expr.id as uint)) {
                 Some(&t) => {
-                    if ty::type_is_immediate(tcx, t) {
-                        RvalueDatumExpr
-                    } else {
+                    if type_is_trait(t) {
                         RvalueDpsExpr
+                    } else {
+                        RvalueDatumExpr
                     }
                 }
                 None => {

branches/auto/src/librustc/middle/ty.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 // Make sure the destructor is run for unit-like structs.
+// xfail-fast
 
 use std::task;
 
@@ -20,7 +21,7 @@ impl Drop for Foo {
     }
 }
 
-pub fn main() {
+fn main() {
     let x = do task::try {
         let _b = Foo;
     };