---

yaml
---
r: 277419
b: refs/heads/try
c: c55d9e5
h: refs/heads/master
i:
  277417: fd6b8c4
  277415: 4d6086f

Author: Aatch

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: 89edd96be86fd65d63f63a208062c8baf86e7d7c
+refs/heads/try: c55d9e591b1f66d4677dac2efda6b70afcd4b345
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/librustc_trans/mir/mod.rs

@@ -16,7 +16,7 @@ use rustc::mir::repr as mir;
 use rustc::mir::tcx::LvalueTy;
 use session::config::FullDebugInfo;
 use base;
-use common::{self, Block, BlockAndBuilder, FunctionContext};
+use common::{self, Block, BlockAndBuilder, CrateContext, FunctionContext};
 use debuginfo::{self, declare_local, DebugLoc, VariableAccess, VariableKind};
 use machine;
 use type_of;
@@ -109,12 +109,21 @@ enum TempRef<'tcx> {
 }
 
 impl<'tcx> TempRef<'tcx> {
-    fn new_operand(val: OperandValue, ty: ty::Ty<'tcx>) -> TempRef<'tcx> {
-        let op = OperandRef {
-            val: val,
-            ty: ty
-        };
-        TempRef::Operand(Some(op))
+    fn new_operand<'bcx>(ccx: &CrateContext<'bcx, 'tcx>,
+                         ty: ty::Ty<'tcx>) -> TempRef<'tcx> {
+        if common::type_is_zero_size(ccx, ty) {
+            // Zero-size temporaries aren't always initialized, which
+            // doesn't matter because they don't contain data, but
+            // we need something in the operand.
+            let val = OperandValue::Immediate(common::C_nil(ccx));
+            let op = OperandRef {
+                val: val,
+                ty: ty
+            };
+            TempRef::Operand(Some(op))
+        } else {
+            TempRef::Operand(None)
+        }
     }
 }
 
@@ -160,17 +169,11 @@ pub fn trans_mir<'blk, 'tcx: 'blk>(fcx: &'blk FunctionContext<'blk, 'tcx>) {
                                   TempRef::Lvalue(LvalueRef::alloca(&bcx,
                                                                     mty,
                                                                     &format!("temp{:?}", i)))
-                              } else if common::type_is_zero_size(bcx.ccx(), mty) {
-                                  // Zero-size temporaries aren't always initialized, which
-                                  // doesn't matter because they don't contain data, but
-                                  // we need something in the operand.
-                                  let val = OperandValue::Immediate(common::C_nil(bcx.ccx()));
-                                  TempRef::new_operand(val, mty)
                               } else {
                                   // If this is an immediate temp, we do not create an
                                   // alloca in advance. Instead we wait until we see the
                                   // definition and update the operand there.
-                                  TempRef::Operand(None)
+                                  TempRef::new_operand(bcx.ccx(), mty)
                               })
                               .collect();