use trans::type_of;
use trans::type_of::*;
use trans::value::Value;
+use trans::Disr;
use util::common::indenter;
use util::sha2::Sha256;
use util::nodemap::{NodeMap, NodeSet};
for (i, field) in variant.fields.iter().enumerate() {
let arg = monomorphize::field_ty(tcx, substs, field);
cx = f(cx,
- adt::trans_field_ptr(cx, repr, av, variant.disr_val, i),
+ adt::trans_field_ptr(cx, repr, av, Disr::from(variant.disr_val), i),
arg);
}
return cx;
let repr = adt::represent_type(cx.ccx(), t);
let VariantInfo { fields, discr } = VariantInfo::from_ty(cx.tcx(), t, None);
for (i, &Field(_, field_ty)) in fields.iter().enumerate() {
- let llfld_a = adt::trans_field_ptr(cx, &*repr, value, discr, i);
+ let llfld_a = adt::trans_field_ptr(cx, &*repr, value, Disr::from(discr), i);
let val = if common::type_is_sized(cx.tcx(), field_ty) {
llfld_a
ty::TyClosure(_, ref substs) => {
let repr = adt::represent_type(cx.ccx(), t);
for (i, upvar_ty) in substs.upvar_tys.iter().enumerate() {
- let llupvar = adt::trans_field_ptr(cx, &*repr, value, 0, i);
+ let llupvar = adt::trans_field_ptr(cx, &*repr, value, Disr(0), i);
cx = f(cx, llupvar, upvar_ty);
}
}
ty::TyTuple(ref args) => {
let repr = adt::represent_type(cx.ccx(), t);
for (i, arg) in args.iter().enumerate() {
- let llfld_a = adt::trans_field_ptr(cx, &*repr, value, 0, i);
+ let llfld_a = adt::trans_field_ptr(cx, &*repr, value, Disr(0), i);
cx = f(cx, llfld_a, *arg);
}
}
let variant_cx = fcx.new_temp_block(&format!("enum-iter-variant-{}",
&variant.disr_val
.to_string()));
- let case_val = adt::trans_case(cx, &*repr, variant.disr_val);
+ let case_val = adt::trans_case(cx, &*repr, Disr::from(variant.disr_val));
AddCase(llswitch, case_val, variant_cx.llbb);
let variant_cx = iter_variant(variant_cx,
&*repr,
continue;
}
- let src_f = adt::trans_field_ptr(bcx, &src_repr, src, 0, i);
- let dst_f = adt::trans_field_ptr(bcx, &dst_repr, dst, 0, i);
+ let src_f = adt::trans_field_ptr(bcx, &src_repr, src, Disr(0), i);
+ let dst_f = adt::trans_field_ptr(bcx, &dst_repr, dst, Disr(0), i);
if src_fty == dst_fty {
memcpy_ty(bcx, dst_f, src_f, src_fty);
} else {
emit: F)
where F: FnOnce(&'blk CrateContext<'blk, 'tcx>, machine::llsize, ValueRef)
{
- if ccx.sess().opts.optimize == config::No {
+ if ccx.sess().opts.optimize == config::OptLevel::No {
return;
}
pub fn trans_enum_variant<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
ctor_id: ast::NodeId,
- disr: ty::Disr,
+ disr: Disr,
param_substs: &'tcx Substs<'tcx>,
llfndecl: ValueRef) {
let _icx = push_ctxt("trans_enum_variant");
pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
ctor_ty: Ty<'tcx>,
- disr: ty::Disr,
+ disr: Disr,
args: callee::CallArgs,
dest: expr::Dest,
debug_loc: DebugLoc)
llfndecl: ValueRef) {
let _icx = push_ctxt("trans_tuple_struct");
- trans_enum_variant_or_tuple_like_struct(ccx, ctor_id, 0, param_substs, llfndecl);
+ trans_enum_variant_or_tuple_like_struct(ccx, ctor_id, Disr(0), param_substs, llfndecl);
}
fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
ctor_id: ast::NodeId,
- disr: ty::Disr,
+ disr: Disr,
param_substs: &'tcx Substs<'tcx>,
llfndecl: ValueRef) {
let ctor_ty = ccx.tcx().node_id_to_type(ctor_id);
let repr = adt::represent_type(ccx, result_ty.unwrap());
let mut llarg_idx = fcx.arg_offset() as c_uint;
for (i, arg_ty) in arg_tys.into_iter().enumerate() {
- let lldestptr = adt::trans_field_ptr(bcx, &*repr, dest_val, disr, i);
+ let lldestptr = adt::trans_field_ptr(bcx, &*repr, dest_val, Disr::from(disr), i);
if common::type_is_fat_ptr(bcx.tcx(), arg_ty) {
Store(bcx,
get_param(fcx.llfn, llarg_idx),
// giving `trans_item` access to this item, so also record a read.
tcx.dep_graph.with_task(DepNode::TransCrateItem(def_id), || {
tcx.dep_graph.read(DepNode::Hir(def_id));
+
+ // We are going to be accessing various tables
+ // generated by TypeckItemBody; we also assume
+ // that the body passes type check. These tables
+ // are not individually tracked, so just register
+ // a read here.
+ tcx.dep_graph.read(DepNode::TypeckItemBody(def_id));
+
trans_item(self.ccx, i);
});