---

yaml
---
r: 63661
b: refs/heads/snap-stage3
c: 42b44b2
h: refs/heads/master
i:
  63659: c52460e
v: v3

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: d161e630d8378e9705987e0b746d8dbf0da48842
+refs/heads/snap-stage3: 42b44b21b11ded0a7dbbe196b1c9d338ef33b614
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/Makefile.in

@@ -239,29 +239,29 @@ $(foreach target,$(CFG_TARGET_TRIPLES),\
 # Standard library variables
 ######################################################################
 
-STDLIB_CRATE := $(S)src/libstd/core.rc
+STDLIB_CRATE := $(S)src/libstd/std.rs
 STDLIB_INPUTS := $(wildcard $(addprefix $(S)src/libstd/,        \
-                                           core.rc *.rs */*.rs */*/*rs */*/*/*rs))
+                                           *.rs */*.rs */*/*rs */*/*/*rs))
 
 ######################################################################
 # Extra library variables
 ######################################################################
 
-EXTRALIB_CRATE := $(S)src/libextra/std.rc
+EXTRALIB_CRATE := $(S)src/libextra/extra.rs
 EXTRALIB_INPUTS := $(wildcard $(addprefix $(S)src/libextra/,          \
-                                          std.rc *.rs */*.rs))
+                                          *.rs */*.rs))
 
 ######################################################################
 # rustc crate variables
 ######################################################################
 
-COMPILER_CRATE := $(S)src/librustc/rustc.rc
+COMPILER_CRATE := $(S)src/librustc/rustc.rs
 COMPILER_INPUTS := $(wildcard $(addprefix $(S)src/librustc/,      \
-                           rustc.rc *.rs */*.rs */*/*.rs */*/*/*.rs))
+                           *.rs */*.rs */*/*.rs */*/*/*.rs))
 
-LIBSYNTAX_CRATE := $(S)src/libsyntax/syntax.rc
+LIBSYNTAX_CRATE := $(S)src/libsyntax/syntax.rs
 LIBSYNTAX_INPUTS := $(wildcard $(addprefix $(S)src/libsyntax/, \
-                            syntax.rc *.rs */*.rs */*/*.rs))
+                           *.rs */*.rs */*/*.rs))
 
 DRIVER_CRATE := $(S)src/driver/driver.rs
 

branches/snap-stage3/mk/tools.mk

@@ -12,23 +12,23 @@
 # and host architectures
 
 # The test runner that runs the cfail/rfail/rpass and bxench tests
-COMPILETEST_CRATE := $(S)src/compiletest/compiletest.rc
-COMPILETEST_INPUTS := $(wildcard $(S)src/compiletest/*rs)
+COMPILETEST_CRATE := $(S)src/compiletest/compiletest.rs
+COMPILETEST_INPUTS := $(wildcard $(S)src/compiletest/*.rs)
 
 # Rustpkg, the package manager and build system
-RUSTPKG_LIB := $(S)src/librustpkg/rustpkg.rc
-RUSTPKG_INPUTS := $(wildcard $(S)src/librustpkg/*rs)
+RUSTPKG_LIB := $(S)src/librustpkg/rustpkg.rs
+RUSTPKG_INPUTS := $(wildcard $(S)src/librustpkg/*.rs)
 
 # Rustdoc, the documentation tool
-RUSTDOC_LIB := $(S)src/librustdoc/rustdoc.rc
+RUSTDOC_LIB := $(S)src/librustdoc/rustdoc.rs
 RUSTDOC_INPUTS := $(wildcard $(S)src/librustdoc/*.rs)
 
 # Rusti, the JIT REPL
-RUSTI_LIB := $(S)src/librusti/rusti.rc
+RUSTI_LIB := $(S)src/librusti/rusti.rs
 RUSTI_INPUTS := $(wildcard $(S)src/librusti/*.rs)
 
 # Rust, the convenience tool
-RUST_LIB := $(S)src/librust/rust.rc
+RUST_LIB := $(S)src/librust/rust.rs
 RUST_INPUTS := $(wildcard $(S)src/librust/*.rs)
 
 # FIXME: These are only built for the host arch. Eventually we'll

branches/snap-stage3/src/compiletest/compiletest.rc renamed to branches/snap-stage3/src/compiletest/compiletest.rs

@@ -70,12 +70,10 @@ impl<T> Rc<T> {
 impl<T> Drop for Rc<T> {
     fn finalize(&self) {
         unsafe {
-            if self.ptr.is_not_null() {
-                (*self.ptr).count -= 1;
-                if (*self.ptr).count == 0 {
-                    ptr::replace_ptr(self.ptr, intrinsics::uninit());
-                    free(self.ptr as *c_void)
-                }
+            (*self.ptr).count -= 1;
+            if (*self.ptr).count == 0 {
+                ptr::replace_ptr(self.ptr, intrinsics::uninit());
+                free(self.ptr as *c_void)
             }
         }
     }
@@ -222,12 +220,10 @@ impl<T> RcMut<T> {
 impl<T> Drop for RcMut<T> {
     fn finalize(&self) {
         unsafe {
-            if self.ptr.is_not_null() {
-                (*self.ptr).count -= 1;
-                if (*self.ptr).count == 0 {
-                    ptr::replace_ptr(self.ptr, uninit());
-                    free(self.ptr as *c_void)
-                }
+            (*self.ptr).count -= 1;
+            if (*self.ptr).count == 0 {
+                ptr::replace_ptr(self.ptr, uninit());
+                free(self.ptr as *c_void)
             }
         }
     }

branches/snap-stage3/src/libextra/std.rc renamed to branches/snap-stage3/src/libextra/extra.rs

@@ -135,7 +135,7 @@ fn represent_type_uncached(cx: &mut CrateContext, t: ty::t) -> Repr {
                 ty::lookup_field_type(cx.tcx, def_id, field.id, substs)
             };
             let packed = ty::lookup_packed(cx.tcx, def_id);
-            let dtor = ty::ty_dtor(cx.tcx, def_id).has_drop_flag();
+            let dtor = ty::ty_dtor(cx.tcx, def_id).is_present();
             let ftys =
                 if dtor { ftys + [ty::mk_bool()] } else { ftys };
             return Univariant(mk_struct(cx, ftys, packed), dtor)

branches/snap-stage3/src/libextra/rc.rs

@@ -404,8 +404,13 @@ pub fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
     build_return(bcx);
 }
 
-pub fn trans_struct_drop_flag(bcx: block, t: ty::t, v0: ValueRef, dtor_did: ast::def_id,
-                              class_did: ast::def_id, substs: &ty::substs) -> block {
+pub fn trans_struct_drop(bcx: block,
+                         t: ty::t,
+                         v0: ValueRef,
+                         dtor_did: ast::def_id,
+                         class_did: ast::def_id,
+                         substs: &ty::substs)
+                      -> block {
     let repr = adt::represent_type(bcx.ccx(), t);
     let drop_flag = adt::trans_drop_flag_ptr(bcx, repr, v0);
     do with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag))) |cx| {
@@ -447,43 +452,6 @@ pub fn trans_struct_drop_flag(bcx: block, t: ty::t, v0: ValueRef, dtor_did: ast:
     }
 }
 
-pub fn trans_struct_drop(mut bcx: block, t: ty::t, v0: ValueRef, dtor_did: ast::def_id,
-                         class_did: ast::def_id, substs: &ty::substs) -> block {
-    let repr = adt::represent_type(bcx.ccx(), t);
-
-    // Find and call the actual destructor
-    let dtor_addr = get_res_dtor(bcx.ccx(), dtor_did,
-                                 class_did, /*bad*/copy substs.tps);
-
-    // The second argument is the "self" argument for drop
-    let params = unsafe {
-        let ty = Type::from_ref(llvm::LLVMTypeOf(dtor_addr));
-        ty.element_type().func_params()
-    };
-
-    // Class dtors have no explicit args, so the params should
-    // just consist of the environment (self)
-    assert_eq!(params.len(), 1);
-
-    // Take a reference to the class (because it's using the Drop trait),
-    // do so now.
-    let llval = alloca(bcx, val_ty(v0));
-    Store(bcx, v0, llval);
-
-    let self_arg = PointerCast(bcx, llval, params[0]);
-    let args = ~[self_arg];
-
-    Call(bcx, dtor_addr, args);
-
-    // Drop the fields
-    let field_tys = ty::struct_fields(bcx.tcx(), class_did, substs);
-    for field_tys.iter().enumerate().advance |(i, fld)| {
-        let llfld_a = adt::trans_field_ptr(bcx, repr, v0, 0, i);
-        bcx = drop_ty(bcx, llfld_a, fld.mt.ty);
-    }
-
-    bcx
-}
 
 pub fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
     // NB: v0 is an *alias* of type t here, not a direct value.
@@ -504,10 +472,7 @@ pub fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
       ty::ty_struct(did, ref substs) => {
         let tcx = bcx.tcx();
         match ty::ty_dtor(tcx, did) {
-          ty::TraitDtor(dtor, true) => {
-            trans_struct_drop_flag(bcx, t, v0, dtor, did, substs)
-          }
-          ty::TraitDtor(dtor, false) => {
+          ty::TraitDtor(dtor) => {
             trans_struct_drop(bcx, t, v0, dtor, did, substs)
           }
           ty::NoDtor => {
@@ -627,23 +592,6 @@ pub fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) {
       ty::ty_opaque_closure_ptr(ck) => {
         closure::make_opaque_cbox_take_glue(bcx, ck, v)
       }
-      ty::ty_struct(did, ref substs) => {
-        let tcx = bcx.tcx();
-        let bcx = iter_structural_ty(bcx, v, t, take_ty);
-
-        match ty::ty_dtor(tcx, did) {
-          ty::TraitDtor(dtor, false) => {
-            // Zero out the struct
-            unsafe {
-                let ty = Type::from_ref(llvm::LLVMTypeOf(v));
-                memzero(bcx, v, ty);
-            }
-
-          }
-          _ => { }
-        }
-        bcx
-      }
       _ if ty::type_is_structural(t) => {
         iter_structural_ty(bcx, v, t, take_ty)
       }

branches/snap-stage3/src/librust/rust.rc renamed to branches/snap-stage3/src/librust/rust.rs

@@ -3852,7 +3852,7 @@ pub fn item_path_str(cx: ctxt, id: ast::def_id) -> ~str {
 
 pub enum DtorKind {
     NoDtor,
-    TraitDtor(def_id, bool)
+    TraitDtor(def_id)
 }
 
 impl DtorKind {
@@ -3866,24 +3866,13 @@ impl DtorKind {
     pub fn is_present(&const self) -> bool {
         !self.is_not_present()
     }
-
-    pub fn has_drop_flag(&self) -> bool {
-        match self {
-            &NoDtor => false,
-            &TraitDtor(_, flag) => flag
-        }
-    }
 }
 
 /* If struct_id names a struct with a dtor, return Some(the dtor's id).
    Otherwise return none. */
 pub fn ty_dtor(cx: ctxt, struct_id: def_id) -> DtorKind {
     match cx.destructor_for_type.find(&struct_id) {
-        Some(&method_def_id) => {
-            let flag = !has_attr(cx, struct_id, "no_drop_flag");
-
-            TraitDtor(method_def_id, flag)
-        }
+        Some(&method_def_id) => TraitDtor(method_def_id),
         None => NoDtor,
     }
 }

branches/snap-stage3/src/librustc/middle/trans/adt.rs

@@ -62,7 +62,6 @@ pub struct AtomicPtr<T> {
 /**
  * An owned atomic pointer. Ensures that only a single reference to the data is held at any time.
  */
-#[no_drop_flag]
 pub struct AtomicOption<T> {
     priv p: *mut c_void
 }