auto merge of #13915 : nick29581/rust/rslt, r=luqmana

bors · bors · commit 1c9b77643c28 · 2014-05-04T07:01:48.000-07:00
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
@@ -340,30 +340,30 @@ fn trans_opt<'a>(bcx: &'a Block<'a>, o: &Opt) -> opt_result<'a> {
             let lit_datum = unpack_datum!(bcx, expr::trans(bcx, lit_expr));
             let lit_datum = lit_datum.assert_rvalue(bcx); // literals are rvalues
             let lit_datum = unpack_datum!(bcx, lit_datum.to_appropriate_datum(bcx));
-            return single_result(rslt(bcx, lit_datum.val));
+            return single_result(Result::new(bcx, lit_datum.val));
         }
         lit(UnitLikeStructLit(pat_id)) => {
             let struct_ty = ty::node_id_to_type(bcx.tcx(), pat_id);
             let datum = datum::rvalue_scratch_datum(bcx, struct_ty, "");
-            return single_result(rslt(bcx, datum.val));
+            return single_result(Result::new(bcx, datum.val));
         }
         lit(ConstLit(lit_id)) => {
             let (llval, _) = consts::get_const_val(bcx.ccx(), lit_id);
-            return single_result(rslt(bcx, llval));
+            return single_result(Result::new(bcx, llval));
         }
         var(disr_val, ref repr) => {
             return adt::trans_case(bcx, &**repr, disr_val);
         }
         range(l1, l2) => {
             let (l1, _) = consts::const_expr(ccx, l1, true);
             let (l2, _) = consts::const_expr(ccx, l2, true);
-            return range_result(rslt(bcx, l1), rslt(bcx, l2));
+            return range_result(Result::new(bcx, l1), Result::new(bcx, l2));
         }
         vec_len(n, vec_len_eq, _) => {
-            return single_result(rslt(bcx, C_int(ccx, n as int)));
+            return single_result(Result::new(bcx, C_int(ccx, n as int)));
         }
         vec_len(n, vec_len_ge(_), _) => {
-            return lower_bound(rslt(bcx, C_int(ccx, n as int)));
+            return lower_bound(Result::new(bcx, C_int(ccx, n as int)));
         }
     }
 }
@@ -1311,7 +1311,7 @@ fn compare_values<'a>(
     let _icx = push_ctxt("compare_values");
     if ty::type_is_scalar(rhs_t) {
         let rs = compare_scalar_types(cx, lhs, rhs, rhs_t, ast::BiEq);
-        return rslt(rs.bcx, rs.val);
+        return Result::new(rs.bcx, rs.val);
     }
 
     match ty::get(rhs_t).sty {
@@ -1742,7 +1742,7 @@ fn compile_submatch_continue<'a, 'b>(
                                   compare_scalar_types(
                                   bcx, test_val, vend,
                                   t, ast::BiLe);
-                              rslt(bcx, And(bcx, llge, llle))
+                              Result::new(bcx, And(bcx, llge, llle))
                           }
                       }
                   };
@@ -1757,14 +1757,14 @@ fn compile_submatch_continue<'a, 'b>(
                               let value = compare_scalar_values(
                                   bcx, test_val, val,
                                   signed_int, ast::BiEq);
-                              rslt(bcx, value)
+                              Result::new(bcx, value)
                           }
                           lower_bound(
                               Result {bcx, val: val}) => {
                               let value = compare_scalar_values(
                                   bcx, test_val, val,
                                   signed_int, ast::BiGe);
-                              rslt(bcx, value)
+                              Result::new(bcx, value)
                           }
                           range_result(
                               Result {val: vbegin, ..},
@@ -1777,7 +1777,7 @@ fn compile_submatch_continue<'a, 'b>(
                                   compare_scalar_values(
                                   bcx, test_val, vend,
                                   signed_int, ast::BiLe);
-                              rslt(bcx, And(bcx, llge, llle))
+                              Result::new(bcx, And(bcx, llge, llle))
                           }
                       }
                   };
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
@@ -579,19 +579,19 @@ pub fn trans_case<'a>(bcx: &'a Block<'a>, r: &Repr, discr: Disr)
                   -> _match::opt_result<'a> {
     match *r {
         CEnum(ity, _, _) => {
-            _match::single_result(rslt(bcx, C_integral(ll_inttype(bcx.ccx(), ity),
-                                                       discr as u64, true)))
+            _match::single_result(Result::new(bcx, C_integral(ll_inttype(bcx.ccx(), ity),
+                                                              discr as u64, true)))
         }
         General(ity, _) => {
-            _match::single_result(rslt(bcx, C_integral(ll_inttype(bcx.ccx(), ity),
-                                                       discr as u64, true)))
+            _match::single_result(Result::new(bcx, C_integral(ll_inttype(bcx.ccx(), ity),
+                                                              discr as u64, true)))
         }
         Univariant(..) => {
             bcx.ccx().sess().bug("no cases for univariants or structs")
         }
         NullablePointer{ .. } => {
             assert!(discr == 0 || discr == 1);
-            _match::single_result(rslt(bcx, C_i1(bcx.ccx(), discr != 0)))
+            _match::single_result(Result::new(bcx, C_i1(bcx.ccx(), discr != 0)))
         }
     }
 }
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
@@ -363,7 +363,7 @@ pub fn malloc_raw_dyn<'a>(bcx: &'a Block<'a>,
         None);
 
     let llty_ptr = type_of::type_of(ccx, ptr_ty);
-    rslt(r.bcx, PointerCast(r.bcx, r.val, llty_ptr))
+    Result::new(r.bcx, PointerCast(r.bcx, r.val, llty_ptr))
 }
 
 pub fn malloc_raw_dyn_managed<'a>(
@@ -393,7 +393,7 @@ pub fn malloc_raw_dyn_managed<'a>(
             llalign
         ],
         None);
-    rslt(r.bcx, PointerCast(r.bcx, r.val, llty))
+    Result::new(r.bcx, PointerCast(r.bcx, r.val, llty))
 }
 
 // Type descriptor and type glue stuff
@@ -543,7 +543,7 @@ pub fn compare_scalar_types<'a>(
                             t: ty::t,
                             op: ast::BinOp)
                             -> Result<'a> {
-    let f = |a| rslt(cx, compare_scalar_values(cx, lhs, rhs, a, op));
+    let f = |a| Result::new(cx, compare_scalar_values(cx, lhs, rhs, a, op));
 
     match ty::get(t).sty {
         ty::ty_nil => f(nil_type),
diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs
@@ -746,7 +746,7 @@ pub fn trans_call_inner<'a>(
         Unreachable(bcx);
     }
 
-    rslt(bcx, llresult)
+    Result::new(bcx, llresult)
 }
 
 pub enum CallArgs<'a> {
@@ -904,5 +904,5 @@ pub fn trans_arg_datum<'a>(
     }
 
     debug!("--- trans_arg_datum passing {}", bcx.val_to_str(val));
-    rslt(bcx, val)
+    Result::new(bcx, val)
 }
diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs
@@ -151,7 +151,7 @@ fn allocate_cbox<'a>(bcx: &'a Block<'a>,
         ty::RegionTraitStore(..) => {
             let cbox_ty = tuplify_box_ty(tcx, cdata_ty);
             let llbox = alloc_ty(bcx, cbox_ty, "__closure");
-            rslt(bcx, llbox)
+            Result::new(bcx, llbox)
         }
     }
 }
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
@@ -466,10 +466,12 @@ pub struct Result<'a> {
     pub val: ValueRef
 }
 
-pub fn rslt<'a>(bcx: &'a Block<'a>, val: ValueRef) -> Result<'a> {
-    Result {
-        bcx: bcx,
-        val: val,
+impl<'a> Result<'a> {
+    pub fn new(bcx: &'a Block<'a>, val: ValueRef) -> Result<'a> {
+        Result {
+            bcx: bcx,
+            val: val,
+        }
     }
 }
 
diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs
@@ -679,6 +679,6 @@ impl<'a> DatumBlock<'a, Expr> {
 
     pub fn to_llbool(self) -> Result<'a> {
         let DatumBlock { datum, bcx } = self;
-        rslt(bcx, datum.to_llbool(bcx))
+        Result::new(bcx, datum.to_llbool(bcx))
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -340,30 +340,30 @@ fn trans_opt<'a>(bcx: &'a Block<'a>, o: &Opt) -> opt_result<'a> {`
`340`	`340`	`let lit_datum = unpack_datum!(bcx, expr::trans(bcx, lit_expr));`
`341`	`341`	`let lit_datum = lit_datum.assert_rvalue(bcx); // literals are rvalues`
`342`	`342`	`let lit_datum = unpack_datum!(bcx, lit_datum.to_appropriate_datum(bcx));`
`343`		`- return single_result(rslt(bcx, lit_datum.val));`
	`343`	`+ return single_result(Result::new(bcx, lit_datum.val));`
`344`	`344`	`}`
`345`	`345`	`lit(UnitLikeStructLit(pat_id)) => {`
`346`	`346`	`let struct_ty = ty::node_id_to_type(bcx.tcx(), pat_id);`
`347`	`347`	`let datum = datum::rvalue_scratch_datum(bcx, struct_ty, "");`
`348`		`- return single_result(rslt(bcx, datum.val));`
	`348`	`+ return single_result(Result::new(bcx, datum.val));`
`349`	`349`	`}`
`350`	`350`	`lit(ConstLit(lit_id)) => {`
`351`	`351`	`let (llval, _) = consts::get_const_val(bcx.ccx(), lit_id);`
`352`		`- return single_result(rslt(bcx, llval));`
	`352`	`+ return single_result(Result::new(bcx, llval));`
`353`	`353`	`}`
`354`	`354`	`var(disr_val, ref repr) => {`
`355`	`355`	`return adt::trans_case(bcx, &**repr, disr_val);`
`356`	`356`	`}`
`357`	`357`	`range(l1, l2) => {`
`358`	`358`	`let (l1, _) = consts::const_expr(ccx, l1, true);`
`359`	`359`	`let (l2, _) = consts::const_expr(ccx, l2, true);`
`360`		`- return range_result(rslt(bcx, l1), rslt(bcx, l2));`
	`360`	`+ return range_result(Result::new(bcx, l1), Result::new(bcx, l2));`
`361`	`361`	`}`
`362`	`362`	`vec_len(n, vec_len_eq, _) => {`
`363`		`- return single_result(rslt(bcx, C_int(ccx, n as int)));`
	`363`	`+ return single_result(Result::new(bcx, C_int(ccx, n as int)));`
`364`	`364`	`}`
`365`	`365`	`vec_len(n, vec_len_ge(_), _) => {`
`366`		`- return lower_bound(rslt(bcx, C_int(ccx, n as int)));`
	`366`	`+ return lower_bound(Result::new(bcx, C_int(ccx, n as int)));`
`367`	`367`	`}`
`368`	`368`	`}`
`369`	`369`	`}`
`@@ -1311,7 +1311,7 @@ fn compare_values<'a>(`
`1311`	`1311`	`let _icx = push_ctxt("compare_values");`
`1312`	`1312`	`if ty::type_is_scalar(rhs_t) {`
`1313`	`1313`	`let rs = compare_scalar_types(cx, lhs, rhs, rhs_t, ast::BiEq);`
`1314`		`- return rslt(rs.bcx, rs.val);`
	`1314`	`+ return Result::new(rs.bcx, rs.val);`
`1315`	`1315`	`}`
`1316`	`1316`
`1317`	`1317`	`match ty::get(rhs_t).sty {`
`@@ -1742,7 +1742,7 @@ fn compile_submatch_continue<'a, 'b>(`
`1742`	`1742`	`compare_scalar_types(`
`1743`	`1743`	`bcx, test_val, vend,`
`1744`	`1744`	`t, ast::BiLe);`
`1745`		`- rslt(bcx, And(bcx, llge, llle))`
	`1745`	`+ Result::new(bcx, And(bcx, llge, llle))`
`1746`	`1746`	`}`
`1747`	`1747`	`}`
`1748`	`1748`	`};`
`@@ -1757,14 +1757,14 @@ fn compile_submatch_continue<'a, 'b>(`
`1757`	`1757`	`let value = compare_scalar_values(`
`1758`	`1758`	`bcx, test_val, val,`
`1759`	`1759`	`signed_int, ast::BiEq);`
`1760`		`- rslt(bcx, value)`
	`1760`	`+ Result::new(bcx, value)`
`1761`	`1761`	`}`
`1762`	`1762`	`lower_bound(`
`1763`	`1763`	`Result {bcx, val: val}) => {`
`1764`	`1764`	`let value = compare_scalar_values(`
`1765`	`1765`	`bcx, test_val, val,`
`1766`	`1766`	`signed_int, ast::BiGe);`
`1767`		`- rslt(bcx, value)`
	`1767`	`+ Result::new(bcx, value)`
`1768`	`1768`	`}`
`1769`	`1769`	`range_result(`
`1770`	`1770`	`Result {val: vbegin, ..},`
`@@ -1777,7 +1777,7 @@ fn compile_submatch_continue<'a, 'b>(`
`1777`	`1777`	`compare_scalar_values(`
`1778`	`1778`	`bcx, test_val, vend,`
`1779`	`1779`	`signed_int, ast::BiLe);`
`1780`		`- rslt(bcx, And(bcx, llge, llle))`
	`1780`	`+ Result::new(bcx, And(bcx, llge, llle))`
`1781`	`1781`	`}`
`1782`	`1782`	`}`
`1783`	`1783`	`};`
Original file line number	Diff line number	Diff line change
`@@ -579,19 +579,19 @@ pub fn trans_case<'a>(bcx: &'a Block<'a>, r: &Repr, discr: Disr)`
`579`	`579`	`-> _match::opt_result<'a> {`
`580`	`580`	`match *r {`
`581`	`581`	`CEnum(ity, _, _) => {`
`582`		`- _match::single_result(rslt(bcx, C_integral(ll_inttype(bcx.ccx(), ity),`
`583`		`- discr as u64, true)))`
	`582`	`+ _match::single_result(Result::new(bcx, C_integral(ll_inttype(bcx.ccx(), ity),`
	`583`	`+ discr as u64, true)))`
`584`	`584`	`}`
`585`	`585`	`General(ity, _) => {`
`586`		`- _match::single_result(rslt(bcx, C_integral(ll_inttype(bcx.ccx(), ity),`
`587`		`- discr as u64, true)))`
	`586`	`+ _match::single_result(Result::new(bcx, C_integral(ll_inttype(bcx.ccx(), ity),`
	`587`	`+ discr as u64, true)))`
`588`	`588`	`}`
`589`	`589`	`Univariant(..) => {`
`590`	`590`	`bcx.ccx().sess().bug("no cases for univariants or structs")`
`591`	`591`	`}`
`592`	`592`	`NullablePointer{ .. } => {`
`593`	`593`	`assert!(discr == 0 \|\| discr == 1);`
`594`		`- _match::single_result(rslt(bcx, C_i1(bcx.ccx(), discr != 0)))`
	`594`	`+ _match::single_result(Result::new(bcx, C_i1(bcx.ccx(), discr != 0)))`
`595`	`595`	`}`
`596`	`596`	`}`
`597`	`597`	`}`
Original file line number	Diff line number	Diff line change
`@@ -746,7 +746,7 @@ pub fn trans_call_inner<'a>(`
`746`	`746`	`Unreachable(bcx);`
`747`	`747`	`}`
`748`	`748`
`749`		`- rslt(bcx, llresult)`
	`749`	`+ Result::new(bcx, llresult)`
`750`	`750`	`}`
`751`	`751`
`752`	`752`	`pub enum CallArgs<'a> {`
`@@ -904,5 +904,5 @@ pub fn trans_arg_datum<'a>(`
`904`	`904`	`}`
`905`	`905`
`906`	`906`	`debug!("--- trans_arg_datum passing {}", bcx.val_to_str(val));`
`907`		`- rslt(bcx, val)`
	`907`	`+ Result::new(bcx, val)`
`908`	`908`	`}`
Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ fn allocate_cbox<'a>(bcx: &'a Block<'a>,`
`151`	`151`	`ty::RegionTraitStore(..) => {`
`152`	`152`	`let cbox_ty = tuplify_box_ty(tcx, cdata_ty);`
`153`	`153`	`let llbox = alloc_ty(bcx, cbox_ty, "__closure");`
`154`		`- rslt(bcx, llbox)`
	`154`	`+ Result::new(bcx, llbox)`
`155`	`155`	`}`
`156`	`156`	`}`
`157`	`157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -466,10 +466,12 @@ pub struct Result<'a> {`
`466`	`466`	`pub val: ValueRef`
`467`	`467`	`}`
`468`	`468`
`469`		`-pub fn rslt<'a>(bcx: &'a Block<'a>, val: ValueRef) -> Result<'a> {`
`470`		`- Result {`
`471`		`- bcx: bcx,`
`472`		`- val: val,`
	`469`	`+impl<'a> Result<'a> {`
	`470`	`+ pub fn new(bcx: &'a Block<'a>, val: ValueRef) -> Result<'a> {`
	`471`	`+ Result {`
	`472`	`+ bcx: bcx,`
	`473`	`+ val: val,`
	`474`	`+ }`
`473`	`475`	`}`
`474`	`476`	`}`
`475`	`477`
Original file line number	Diff line number	Diff line change
`@@ -679,6 +679,6 @@ impl<'a> DatumBlock<'a, Expr> {`
`679`	`679`
`680`	`680`	`pub fn to_llbool(self) -> Result<'a> {`
`681`	`681`	`let DatumBlock { datum, bcx } = self;`
`682`		`- rslt(bcx, datum.to_llbool(bcx))`
	`682`	`+ Result::new(bcx, datum.to_llbool(bcx))`
`683`	`683`	`}`
`684`	`684`	`}`