};
debug!("make_shim({:?}) = untransformed {:?}", instance, result);
- run_passes(tcx, &mut result, instance, MirPhase::Const, &[
+ run_passes(tcx, &mut result, instance, None, MirPhase::Const, &[
&add_moves_for_packed_drops::AddMovesForPackedDrops,
&no_landing_pads::NoLandingPads,
&remove_noop_landing_pads::RemoveNoopLandingPads,
SourceScopeData { span: span, parent_scope: None }, 1
),
ClearCrossCrate::Clear,
- IndexVec::new(),
None,
local_decls_for_sig(&sig, span),
IndexVec::new(),
// Function arguments should be retagged, and we make this one raw.
body.basic_blocks_mut()[START_BLOCK].statements.insert(0, Statement {
source_info,
- kind: StatementKind::Retag(RetagKind::Raw, dropee_ptr.clone()),
+ kind: StatementKind::Retag(RetagKind::Raw, box(dropee_ptr.clone())),
});
}
let patch = {
let mut builder = CloneShimBuilder::new(tcx, def_id, self_ty);
let is_copy = self_ty.is_copy_modulo_regions(tcx, param_env, builder.span);
- let dest = Place::RETURN_PLACE;
+ let dest = Place::return_place();
let src = Place::from(Local::new(1+0)).deref();
match self_ty.sty {
SourceScopeData { span: self.span, parent_scope: None }, 1
),
ClearCrossCrate::Clear,
- IndexVec::new(),
None,
self.local_decls,
IndexVec::new(),
let rcvr = Place::from(Local::new(1+0)).deref();
let ret_statement = self.make_statement(
StatementKind::Assign(
- Place::RETURN_PLACE,
- box Rvalue::Use(Operand::Copy(rcvr))
+ box(
+ Place::return_place(),
+ Rvalue::Use(Operand::Copy(rcvr))
+ )
)
);
self.block(vec![ret_statement], TerminatorKind::Return, false);
let func_ty = tcx.mk_fn_def(self.def_id, substs);
let func = Operand::Constant(box Constant {
span: self.span,
- ty: func_ty,
user_ty: None,
literal: ty::Const::zero_sized(tcx, func_ty),
});
// `let ref_loc: &ty = &src;`
let statement = self.make_statement(
StatementKind::Assign(
- ref_loc.clone(),
- box Rvalue::Ref(tcx.lifetimes.re_erased, BorrowKind::Shared, src)
+ box(
+ ref_loc.clone(),
+ Rvalue::Ref(tcx.lifetimes.re_erased, BorrowKind::Shared, src)
+ )
)
);
let cond = self.make_place(Mutability::Mut, tcx.types.bool);
let compute_cond = self.make_statement(
StatementKind::Assign(
- cond.clone(),
- box Rvalue::BinaryOp(BinOp::Ne, Operand::Copy(end), Operand::Copy(beg))
+ box(
+ cond.clone(),
+ Rvalue::BinaryOp(BinOp::Ne, Operand::Copy(end), Operand::Copy(beg))
+ )
)
);
fn make_usize(&self, value: u64) -> Box<Constant<'tcx>> {
box Constant {
span: self.span,
- ty: self.tcx.types.usize,
user_ty: None,
literal: ty::Const::from_usize(self.tcx, value),
}
let inits = vec![
self.make_statement(
StatementKind::Assign(
- Place::from(beg),
- box Rvalue::Use(Operand::Constant(self.make_usize(0)))
+ box(
+ Place::from(beg),
+ Rvalue::Use(Operand::Constant(self.make_usize(0)))
+ )
)
),
self.make_statement(
StatementKind::Assign(
- end.clone(),
- box Rvalue::Use(Operand::Constant(self.make_usize(len)))
+ box(
+ end.clone(),
+ Rvalue::Use(Operand::Constant(self.make_usize(len)))
+ )
)
)
];
let statements = vec![
self.make_statement(
StatementKind::Assign(
- Place::from(beg),
- box Rvalue::BinaryOp(
- BinOp::Add,
- Operand::Copy(Place::from(beg)),
- Operand::Constant(self.make_usize(1))
+ box(
+ Place::from(beg),
+ Rvalue::BinaryOp(
+ BinOp::Add,
+ Operand::Copy(Place::from(beg)),
+ Operand::Constant(self.make_usize(1))
+ )
)
)
)
let beg = self.local_decls.push(temp_decl(Mutability::Mut, tcx.types.usize, span));
let init = self.make_statement(
StatementKind::Assign(
- Place::from(beg),
- box Rvalue::Use(Operand::Constant(self.make_usize(0)))
+ box(
+ Place::from(beg),
+ Rvalue::Use(Operand::Constant(self.make_usize(0)))
+ )
)
);
self.block(vec![init], TerminatorKind::Goto { target: BasicBlock::new(6) }, true);
// `goto #6;`
let statement = self.make_statement(
StatementKind::Assign(
- Place::from(beg),
- box Rvalue::BinaryOp(
- BinOp::Add,
- Operand::Copy(Place::from(beg)),
- Operand::Constant(self.make_usize(1))
+ box(
+ Place::from(beg),
+ Rvalue::BinaryOp(
+ BinOp::Add,
+ Operand::Copy(Place::from(beg)),
+ Operand::Constant(self.make_usize(1))
+ )
)
)
);
Adjustment::DerefMove => {
// fn(Self, ...) -> fn(*mut Self, ...)
let arg_ty = local_decls[rcvr_arg].ty;
- assert!(arg_ty.is_self());
+ debug_assert!(tcx.generics_of(def_id).has_self && arg_ty == tcx.types.self_param);
local_decls[rcvr_arg].ty = tcx.mk_mut_ptr(arg_ty);
Operand::Move(rcvr_l.deref())
statements.push(Statement {
source_info,
kind: StatementKind::Assign(
- Place::from(ref_rcvr),
- box Rvalue::Ref(tcx.lifetimes.re_erased, borrow_kind, rcvr_l)
+ box(
+ Place::from(ref_rcvr),
+ Rvalue::Ref(tcx.lifetimes.re_erased, borrow_kind, rcvr_l)
+ )
)
});
Operand::Move(Place::from(ref_rcvr))
let ty = tcx.type_of(def_id);
(Operand::Constant(box Constant {
span,
- ty,
user_ty: None,
literal: ty::Const::zero_sized(tcx, ty),
}),
block(&mut blocks, statements, TerminatorKind::Call {
func: callee,
args,
- destination: Some((Place::RETURN_PLACE,
+ destination: Some((Place::return_place(),
BasicBlock::new(1))),
cleanup: if let Adjustment::RefMut = rcvr_adjustment {
Some(BasicBlock::new(3))
SourceScopeData { span: span, parent_scope: None }, 1
),
ClearCrossCrate::Clear,
- IndexVec::new(),
None,
local_decls,
IndexVec::new(),
debug!("build_ctor: variant_index={:?}", variant_index);
let statements = expand_aggregate(
- Place::RETURN_PLACE,
+ Place::return_place(),
adt_def
.variants[variant_index]
.fields
SourceScopeData { span: span, parent_scope: None }, 1
),
ClearCrossCrate::Clear,
- IndexVec::new(),
None,
local_decls,
IndexVec::new(),