let_extent_stack.push(remainder_scope);
unpack!(block = this.in_scope(init_scope, block, move |this| {
// FIXME #30046 ^~~~
- match initializer {
- Some(initializer) => {
- this.expr_into_pattern(block,
- remainder_scope,
- pattern,
- initializer)
- }
- None => {
- this.declare_bindings(remainder_scope, &pattern);
- block.unit()
- }
+ if let Some(init) = initializer {
+ this.expr_into_pattern(block, remainder_scope, pattern, init)
+ } else {
+ this.declare_bindings(remainder_scope, &pattern);
+ block.unit()
}
}));
}
fn make_mirror<'a>(self, cx: &mut Cx<'a, 'tcx>) -> Block<'tcx> {
// We have to eagerly translate the "spine" of the statements
// in order to get the lexical scoping correctly.
- let stmts = mirror_stmts(cx, self.id, self.stmts.iter().enumerate());
+ let stmts = mirror_stmts(cx, self.id, &*self.stmts);
Block {
extent: cx.tcx.region_maps.node_extent(self.id),
span: self.span,
}
}
-fn mirror_stmts<'a,'tcx:'a,STMTS>(cx: &mut Cx<'a,'tcx>,
- block_id: ast::NodeId,
- mut stmts: STMTS)
- -> Vec<StmtRef<'tcx>>
- where STMTS: Iterator<Item=(usize, &'tcx hir::Stmt)>
+fn mirror_stmts<'a,'tcx:'a>(cx: &mut Cx<'a,'tcx>,
+ block_id: ast::NodeId,
+ stmts: &'tcx [hir::Stmt])
+ -> Vec<StmtRef<'tcx>>
{
let mut result = vec![];
- while let Some((index, stmt)) = stmts.next() {
+ for (index, stmt) in stmts.iter().enumerate() {
match stmt.node {
hir::StmtExpr(ref expr, id) | hir::StmtSemi(ref expr, id) =>
result.push(StmtRef::Mirror(Box::new(Stmt {
expr: expr.to_ref()
}
}))),
- hir::StmtDecl(ref decl, id) => {
- match decl.node {
- hir::DeclItem(..) => { /* ignore for purposes of the MIR */ }
- hir::DeclLocal(ref local) => {
- let remainder_extent = CodeExtentData::Remainder(BlockRemainder {
- block: block_id,
- first_statement_index: index as u32,
- });
- let remainder_extent =
- cx.tcx.region_maps.lookup_code_extent(remainder_extent);
+ hir::StmtDecl(ref decl, id) => match decl.node {
+ hir::DeclItem(..) => { /* ignore for purposes of the MIR */ }
+ hir::DeclLocal(ref local) => {
+ let remainder_extent = CodeExtentData::Remainder(BlockRemainder {
+ block: block_id,
+ first_statement_index: index as u32,
+ });
+ let remainder_extent =
+ cx.tcx.region_maps.lookup_code_extent(remainder_extent);
- let pattern = cx.irrefutable_pat(&local.pat);
- result.push(StmtRef::Mirror(Box::new(Stmt {
- span: stmt.span,
- kind: StmtKind::Let {
- remainder_scope: remainder_extent,
- init_scope: cx.tcx.region_maps.node_extent(id),
- pattern: pattern,
- initializer: local.init.to_ref(),
- },
- })));
- }
+ let pattern = cx.irrefutable_pat(&local.pat);
+ result.push(StmtRef::Mirror(Box::new(Stmt {
+ span: stmt.span,
+ kind: StmtKind::Let {
+ remainder_scope: remainder_extent,
+ init_scope: cx.tcx.region_maps.node_extent(id),
+ pattern: pattern,
+ initializer: local.init.to_ref(),
+ },
+ })));
}
}
}
match *rvalue {
mir::Rvalue::Use(ref operand) => {
+ let tr_operand = self.trans_operand(&bcx, operand);
// FIXME: consider not copying constants through stack. (fixable by translating
// constants into OperandValue::Ref, why don’t we do that yet if we don’t?)
- let tr_operand = self.trans_operand(&bcx, operand);
self.store_operand(&bcx, dest.llval, tr_operand);
self.set_operand_dropped(&bcx, operand);
bcx
}
// (*) this is only true if the type is suitable
- // (**) we need to zero-out the old value before moving, so we are restricted to either
- // ensuring all users of `Use` set it themselves or not allowing to “create” operand for it.
+ // (**) we need to zero-out the source operand after moving, so we are restricted to either
+ // ensuring all users of `Use` zero it out themselves or not allowing to “create” operand for
+ // it.
}