---

yaml
---
r: 45022
b: refs/heads/master
c: 2a028c5
h: refs/heads/master
v: v3

Author: jld

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 80844f993d8964ca89630115c5c0f7e8beb315cb
+refs/heads/master: 2a028c5ab8363d9263d0cda09d6ab884c5b73978
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/librustc/middle/trans/adt.rs

@@ -378,3 +378,12 @@ fn const_struct_field(ccx: @CrateContext, val: ValueRef, ix: uint)
         real_ix = real_ix + 1;
     }
 }
+
+/// Is it safe to bitcast a value to the one field of its one variant?
+pub fn is_newtypeish(r: &Repr) -> bool {
+    match *r {
+        Univariant(ref st, DtorAbsent)
+        | Univariant(ref st, NoDtor) => st.fields.len() == 1,
+        _ => false
+    }
+}

trunk/src/librustc/middle/trans/datum.rs

@@ -90,6 +90,7 @@ use core::prelude::*;
 use lib;
 use lib::llvm::ValueRef;
 use middle::borrowck::{RootInfo, root_map_key};
+use middle::trans::adt;
 use middle::trans::base::*;
 use middle::trans::build::*;
 use middle::trans::callee;
@@ -677,15 +678,17 @@ pub impl Datum {
                     return (None, bcx);
                 }
 
+                let repr = adt::represent_type(ccx, self.ty);
+                assert adt::is_newtypeish(&repr);
                 let ty = ty::subst(ccx.tcx, substs, variants[0].args[0]);
                 return match self.mode {
                     ByRef => {
                         // Recast lv.val as a pointer to the newtype
                         // rather than a ptr to the enum type.
-                        let llty = T_ptr(type_of::type_of(ccx, ty));
                         (
                             Some(Datum {
-                                val: PointerCast(bcx, self.val, llty),
+                                val: adt::trans_GEP(bcx, &repr, self.val,
+                                                    0, 0),
                                 ty: ty,
                                 mode: ByRef,
                                 source: ZeroMem
@@ -715,6 +718,8 @@ pub impl Datum {
                     return (None, bcx);
                 }
 
+                let repr = adt::represent_type(ccx, self.ty);
+                assert adt::is_newtypeish(&repr);
                 let ty = fields[0].mt.ty;
                 return match self.mode {
                     ByRef => {
@@ -724,7 +729,8 @@ pub impl Datum {
                         // destructors.
                         (
                             Some(Datum {
-                                val: GEPi(bcx, self.val, [0, 0, 0]),
+                                val: adt::trans_GEP(bcx, &repr, self.val,
+                                                    0, 0),
                                 ty: ty,
                                 mode: ByRef,
                                 source: ZeroMem