---

yaml
---
r: 95861
b: refs/heads/dist-snap
c: c118b89
h: refs/heads/master
i:
  95859: f12a676
v: v3

Author: nibrahim

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 702767db65c9b9d4e601ec5de836246fb9a9e462
+refs/heads/dist-snap: c118b89ad94ecabf3de85f8e8df81f0acf552caa
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/tutorial.md

@@ -759,6 +759,7 @@ different type from `Bar(1, 2)`), and tuple structs' _fields_ do not have
 names.
 
 For example:
+
 ~~~~
 struct MyTup(int, int, f64);
 let mytup: MyTup = MyTup(10, 20, 30.0);

branches/dist-snap/src/librustc/middle/trans/glue.rs

@@ -395,11 +395,39 @@ pub fn trans_struct_drop_flag(bcx: @mut Block, t: ty::t, v0: ValueRef, dtor_did:
     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| {
-        trans_struct_drop(cx, t, v0, dtor_did, class_did, substs)
+        let mut bcx = cx;
+
+        // Find and call the actual destructor
+        let dtor_addr = get_res_dtor(bcx.ccx(), dtor_did,
+                                     class_did, substs.tps.clone());
+
+        // 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);
+
+        let self_arg = PointerCast(bcx, v0, 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 (i, fld) in field_tys.iter().enumerate() {
+            let llfld_a = adt::trans_field_ptr(bcx, repr, v0, 0, i);
+            bcx = drop_ty(bcx, llfld_a, fld.mt.ty);
+        }
+
+        bcx
     }
 }
 
-pub fn trans_struct_drop(bcx: @mut Block, t: ty::t, v0: ValueRef, dtor_did: ast::DefId,
+pub fn trans_struct_drop(mut bcx: @mut Block, t: ty::t, v0: ValueRef, dtor_did: ast::DefId,
                          class_did: ast::DefId, substs: &ty::substs) -> @mut Block {
     let repr = adt::represent_type(bcx.ccx(), t);
 
@@ -417,24 +445,19 @@ pub fn trans_struct_drop(bcx: @mut Block, t: ty::t, v0: ValueRef, dtor_did: ast:
     // just consist of the environment (self)
     assert_eq!(params.len(), 1);
 
-    // Be sure to put all of the fields into a scope so we can use an invoke
-    // instruction to call the user destructor but still call the field
-    // destructors if the user destructor fails.
-    do with_scope(bcx, None, "field drops") |bcx| {
-        let self_arg = PointerCast(bcx, v0, params[0]);
-        let args = ~[self_arg];
+    let self_arg = PointerCast(bcx, v0, params[0]);
+    let args = ~[self_arg];
 
-        // Add all the fields as a value which needs to be cleaned at the end of
-        // this scope.
-        let field_tys = ty::struct_fields(bcx.tcx(), class_did, substs);
-        for (i, fld) in field_tys.iter().enumerate() {
-            let llfld_a = adt::trans_field_ptr(bcx, repr, v0, 0, i);
-            add_clean(bcx, llfld_a, fld.mt.ty);
-        }
+    Call(bcx, dtor_addr, args, []);
 
-        let (_, bcx) = invoke(bcx, dtor_addr, args, []);
-        bcx
+    // Drop the fields
+    let field_tys = ty::struct_fields(bcx.tcx(), class_did, substs);
+    for (i, fld) in field_tys.iter().enumerate() {
+        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: @mut Block, v0: ValueRef, t: ty::t) -> @mut Block {