OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Auto merge of #37642 - nnethercote:no-HirVec-of-P, r=michaelwoerister

Browse Source 
Change HirVec<P<T>> to HirVec<T> in hir:: Expr.

This PR changes data structures like this:
```
[ ExprArray | 8 | P ]
                  |
                  v
                  [ P | P | P | P | P | P | P | P ]
                    |
                    v
                    [ ExprTup | 2 | P ]
                                    |
                                    v
                                    [ P | P ]
                                      |
                                      v
                                      [ Expr ]
```
to this:
```
[ ExprArray | 8 | P ]
                  |
                  v
                  [ [ ExprTup | 2 | P ] | ... ]
                                    |
                                    v
                                    [ Expr | Expr ]
```
I thought this would be a win for #36799, and on a cut-down version of that workload this reduces the peak heap size (as measured by Massif) from 885 MiB to 875 MiB. However, the peak RSS as measured by `-Ztime-passes` and by `/usr/bin/time` increases by about 30 MiB.

I'm not sure why. Just look at the picture above -- the second data structure clearly takes up less space than the first. My best idea relates to unused elements in the slices. `HirVec<Expr>` is a typedef for `P<[Expr]>`. If there were any unused excess elements then I could see that memory usage would increase, because those excess elements are larger in `HirVec<Expr>` than in `HirVec<P<Expr>>`. But AIUI there are no such excess elements, and Massif's measurements corroborate that.

However, the two main creation points for these data structures are these lines from `lower_expr`:
```rust
        ExprKind::Vec(ref exprs) => {
            hir::ExprArray(exprs.iter().map(|x| self.lower_expr(x)).collect())
        }
        ExprKind::Tup(ref elts) => {
            hir::ExprTup(elts.iter().map(|x| self.lower_expr(x)).collect())
        }
```
I suspect what is happening is that temporary excess elements are created within the `collect` calls. The workload from #36799 has many 2-tuples and 3-tuples and when `Vec` gets doubled it goes from a capacity of 1 to 4, which would lead to excess elements. Though, having said that, `Vec::with_capacity` doesn't create excess AFAICT. So I'm not sure. What goes on inside `collect` is complex.

Anyway, in its current form this PR is a memory consumption regression and so not worth landing but I figured I'd post it in case anyone has additional insight.
This commit is contained in:
bors 2016-11-21 17:59:10 -06:00 committed by GitHub
commit 82d8833a45
10 changed files with 183 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/librustc/cfg/construct.rs
View File

@ -299,15 +299,15 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
} }
hir::ExprArray(ref elems) => { hir::ExprArray(ref elems) => {
self.straightline(expr, pred, elems.iter().map(|e| &**e)) self.straightline(expr, pred, elems.iter().map(|e| &*e))
} }
hir::ExprCall(ref func, ref args) => { hir::ExprCall(ref func, ref args) => {
self.call(expr, pred, &func, args.iter().map(|e| &**e)) self.call(expr, pred, &func, args.iter().map(|e| &*e))
} }
hir::ExprMethodCall(.., ref args) => { hir::ExprMethodCall(.., ref args) => {
self.call(expr, pred, &args[0], args[1..].iter().map(|e| &**e)) self.call(expr, pred, &args[0], args[1..].iter().map(|e| &*e))
} }
hir::ExprIndex(ref l, ref r) | hir::ExprIndex(ref l, ref r) |
@ -320,7 +320,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
} }
hir::ExprTup(ref exprs) => { hir::ExprTup(ref exprs) => {
self.straightline(expr, pred, exprs.iter().map(|e| &**e)) self.straightline(expr, pred, exprs.iter().map(|e| &*e))
} }
hir::ExprStruct(_, ref fields, ref base) => { hir::ExprStruct(_, ref fields, ref base) => {
@ -353,8 +353,8 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
} }
hir::ExprInlineAsm(_, ref outputs, ref inputs) => { hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
let post_outputs = self.exprs(outputs.iter().map(|e| &**e), pred); let post_outputs = self.exprs(outputs.iter().map(|e| &*e), pred);
let post_inputs = self.exprs(inputs.iter().map(|e| &**e), post_outputs); let post_inputs = self.exprs(inputs.iter().map(|e| &*e), post_outputs);
self.add_ast_node(expr.id, &[post_inputs]) self.add_ast_node(expr.id, &[post_inputs])
} }

278
src/librustc/hir/lowering.rs
View File

@ -210,8 +210,8 @@ impl<'a> LoweringContext<'a> {
hir::Arm { hir::Arm {
attrs: self.lower_attrs(&arm.attrs), attrs: self.lower_attrs(&arm.attrs),
pats: arm.pats.iter().map(|x| self.lower_pat(x)).collect(), pats: arm.pats.iter().map(|x| self.lower_pat(x)).collect(),
guard: arm.guard.as_ref().map(|ref x| self.lower_expr(x)), guard: arm.guard.as_ref().map(|ref x| P(self.lower_expr(x))),
body: self.lower_expr(&arm.body), body: P(self.lower_expr(&arm.body)),
} }
} }
@ -262,10 +262,10 @@ impl<'a> LoweringContext<'a> {
hir::TyObjectSum(self.lower_ty(ty), self.lower_bounds(bounds)) hir::TyObjectSum(self.lower_ty(ty), self.lower_bounds(bounds))
} }
TyKind::Array(ref ty, ref e) => { TyKind::Array(ref ty, ref e) => {
hir::TyArray(self.lower_ty(ty), self.lower_expr(e)) hir::TyArray(self.lower_ty(ty), P(self.lower_expr(e)))
} }
TyKind::Typeof(ref expr) => { TyKind::Typeof(ref expr) => {
hir::TyTypeof(self.lower_expr(expr)) hir::TyTypeof(P(self.lower_expr(expr)))
} }
TyKind::PolyTraitRef(ref bounds) => { TyKind::PolyTraitRef(ref bounds) => {
hir::TyPolyTraitRef(self.lower_bounds(bounds)) hir::TyPolyTraitRef(self.lower_bounds(bounds))
@ -292,7 +292,7 @@ impl<'a> LoweringContext<'a> {
name: v.node.name.name, name: v.node.name.name,
attrs: self.lower_attrs(&v.node.attrs), attrs: self.lower_attrs(&v.node.attrs),
data: self.lower_variant_data(&v.node.data), data: self.lower_variant_data(&v.node.data),
disr_expr: v.node.disr_expr.as_ref().map(|e| self.lower_expr(e)), disr_expr: v.node.disr_expr.as_ref().map(|e| P(self.lower_expr(e))),
}, },
span: v.span, span: v.span,
} }
@ -350,7 +350,7 @@ impl<'a> LoweringContext<'a> {
id: l.id, id: l.id,
ty: l.ty.as_ref().map(|t| self.lower_ty(t)), ty: l.ty.as_ref().map(|t| self.lower_ty(t)),
pat: self.lower_pat(&l.pat), pat: self.lower_pat(&l.pat),
init: l.init.as_ref().map(|e| self.lower_expr(e)), init: l.init.as_ref().map(|e| P(self.lower_expr(e))),
span: l.span, span: l.span,
attrs: l.attrs.clone(), attrs: l.attrs.clone(),
}) })
@ -550,7 +550,7 @@ impl<'a> LoweringContext<'a> {
fn lower_field(&mut self, f: &Field) -> hir::Field { fn lower_field(&mut self, f: &Field) -> hir::Field {
hir::Field { hir::Field {
name: respan(f.ident.span, f.ident.node.name), name: respan(f.ident.span, f.ident.node.name),
expr: self.lower_expr(&f.expr), expr: P(self.lower_expr(&f.expr)),
span: f.span, span: f.span,
is_shorthand: f.is_shorthand, is_shorthand: f.is_shorthand,
} }
@ -599,10 +599,10 @@ impl<'a> LoweringContext<'a> {
ItemKind::Static(ref t, m, ref e) => { ItemKind::Static(ref t, m, ref e) => {
hir::ItemStatic(self.lower_ty(t), hir::ItemStatic(self.lower_ty(t),
self.lower_mutability(m), self.lower_mutability(m),
self.lower_expr(e)) P(self.lower_expr(e)))
} }
ItemKind::Const(ref t, ref e) => { ItemKind::Const(ref t, ref e) => {
hir::ItemConst(self.lower_ty(t), self.lower_expr(e)) hir::ItemConst(self.lower_ty(t), P(self.lower_expr(e)))
} }
ItemKind::Fn(ref decl, unsafety, constness, abi, ref generics, ref body) => { ItemKind::Fn(ref decl, unsafety, constness, abi, ref generics, ref body) => {
let body = self.lower_block(body); let body = self.lower_block(body);
@ -611,7 +611,7 @@ impl<'a> LoweringContext<'a> {
self.lower_constness(constness), self.lower_constness(constness),
abi, abi,
self.lower_generics(generics), self.lower_generics(generics),
self.expr_block(body, ThinVec::new())) P(self.expr_block(body, ThinVec::new())))
} }
ItemKind::Mod(ref m) => hir::ItemMod(self.lower_mod(m)), ItemKind::Mod(ref m) => hir::ItemMod(self.lower_mod(m)),
ItemKind::ForeignMod(ref nm) => hir::ItemForeignMod(self.lower_foreign_mod(nm)), ItemKind::ForeignMod(ref nm) => hir::ItemForeignMod(self.lower_foreign_mod(nm)),
@ -672,13 +672,13 @@ impl<'a> LoweringContext<'a> {
node: match i.node { node: match i.node {
TraitItemKind::Const(ref ty, ref default) => { TraitItemKind::Const(ref ty, ref default) => {
hir::ConstTraitItem(this.lower_ty(ty), hir::ConstTraitItem(this.lower_ty(ty),
default.as_ref().map(|x| this.lower_expr(x))) default.as_ref().map(|x| P(this.lower_expr(x))))
} }
TraitItemKind::Method(ref sig, ref body) => { TraitItemKind::Method(ref sig, ref body) => {
hir::MethodTraitItem(this.lower_method_sig(sig), hir::MethodTraitItem(this.lower_method_sig(sig),
body.as_ref().map(|x| { body.as_ref().map(|x| {
let body = this.lower_block(x); let body = this.lower_block(x);
this.expr_block(body, ThinVec::new()) P(this.expr_block(body, ThinVec::new()))
})) }))
} }
TraitItemKind::Type(ref bounds, ref default) => { TraitItemKind::Type(ref bounds, ref default) => {
@ -702,12 +702,12 @@ impl<'a> LoweringContext<'a> {
defaultness: this.lower_defaultness(i.defaultness, true /* [1] */), defaultness: this.lower_defaultness(i.defaultness, true /* [1] */),
node: match i.node { node: match i.node {
ImplItemKind::Const(ref ty, ref expr) => { ImplItemKind::Const(ref ty, ref expr) => {
hir::ImplItemKind::Const(this.lower_ty(ty), this.lower_expr(expr)) hir::ImplItemKind::Const(this.lower_ty(ty), P(this.lower_expr(expr)))
} }
ImplItemKind::Method(ref sig, ref body) => { ImplItemKind::Method(ref sig, ref body) => {
let body = this.lower_block(body); let body = this.lower_block(body);
hir::ImplItemKind::Method(this.lower_method_sig(sig), hir::ImplItemKind::Method(this.lower_method_sig(sig),
this.expr_block(body, ThinVec::new())) P(this.expr_block(body, ThinVec::new())))
} }
ImplItemKind::Type(ref ty) => hir::ImplItemKind::Type(this.lower_ty(ty)), ImplItemKind::Type(ref ty) => hir::ImplItemKind::Type(this.lower_ty(ty)),
ImplItemKind::Macro(..) => panic!("Shouldn't exist any more"), ImplItemKind::Macro(..) => panic!("Shouldn't exist any more"),
@ -885,7 +885,7 @@ impl<'a> LoweringContext<'a> {
} }
}) })
} }
PatKind::Lit(ref e) => hir::PatKind::Lit(self.lower_expr(e)), PatKind::Lit(ref e) => hir::PatKind::Lit(P(self.lower_expr(e))),
PatKind::TupleStruct(ref path, ref pats, ddpos) => { PatKind::TupleStruct(ref path, ref pats, ddpos) => {
hir::PatKind::TupleStruct(self.lower_path(path), hir::PatKind::TupleStruct(self.lower_path(path),
pats.iter().map(|x| self.lower_pat(x)).collect(), ddpos) pats.iter().map(|x| self.lower_pat(x)).collect(), ddpos)
@ -920,7 +920,7 @@ impl<'a> LoweringContext<'a> {
hir::PatKind::Ref(self.lower_pat(inner), self.lower_mutability(mutbl)) hir::PatKind::Ref(self.lower_pat(inner), self.lower_mutability(mutbl))
} }
PatKind::Range(ref e1, ref e2) => { PatKind::Range(ref e1, ref e2) => {
hir::PatKind::Range(self.lower_expr(e1), self.lower_expr(e2)) hir::PatKind::Range(P(self.lower_expr(e1)), P(self.lower_expr(e2)))
} }
PatKind::Slice(ref before, ref slice, ref after) => { PatKind::Slice(ref before, ref slice, ref after) => {
hir::PatKind::Slice(before.iter().map(|x| self.lower_pat(x)).collect(), hir::PatKind::Slice(before.iter().map(|x| self.lower_pat(x)).collect(),
@ -933,8 +933,8 @@ impl<'a> LoweringContext<'a> {
}) })
} }
fn lower_expr(&mut self, e: &Expr) -> P<hir::Expr> { fn lower_expr(&mut self, e: &Expr) -> hir::Expr {
P(hir::Expr { hir::Expr {
id: e.id, id: e.id,
node: match e.node { node: match e.node {
// Issue #22181: // Issue #22181:
@ -954,7 +954,7 @@ impl<'a> LoweringContext<'a> {
// //
// But for now there are type-inference issues doing that. // But for now there are type-inference issues doing that.
ExprKind::Box(ref e) => { ExprKind::Box(ref e) => {
hir::ExprBox(self.lower_expr(e)) hir::ExprBox(P(self.lower_expr(e)))
} }
// Desugar ExprBox: `in (PLACE) EXPR` // Desugar ExprBox: `in (PLACE) EXPR`
@ -968,8 +968,8 @@ impl<'a> LoweringContext<'a> {
// std::intrinsics::move_val_init(raw_place, pop_unsafe!( EXPR )); // std::intrinsics::move_val_init(raw_place, pop_unsafe!( EXPR ));
// InPlace::finalize(place) // InPlace::finalize(place)
// }) // })
let placer_expr = self.lower_expr(placer); let placer_expr = P(self.lower_expr(placer));
let value_expr = self.lower_expr(value_expr); let value_expr = P(self.lower_expr(value_expr));
let placer_ident = self.str_to_ident("placer"); let placer_ident = self.str_to_ident("placer");
let place_ident = self.str_to_ident("place"); let place_ident = self.str_to_ident("place");
@ -983,7 +983,7 @@ impl<'a> LoweringContext<'a> {
let make_call = |this: &mut LoweringContext, p, args| { let make_call = |this: &mut LoweringContext, p, args| {
let path = this.std_path(e.span, p); let path = this.std_path(e.span, p);
let path = this.expr_path(path, ThinVec::new()); let path = this.expr_path(path, ThinVec::new());
this.expr_call(e.span, path, args) P(this.expr_call(e.span, path, args))
}; };
let mk_stmt_let = |this: &mut LoweringContext, bind, expr| { let mk_stmt_let = |this: &mut LoweringContext, bind, expr| {
@ -996,11 +996,11 @@ impl<'a> LoweringContext<'a> {
// let placer = <placer_expr> ; // let placer = <placer_expr> ;
let (s1, placer_binding) = { let (s1, placer_binding) = {
let placer_expr = self.signal_block_expr(hir_vec![], let placer_expr = P(self.signal_block_expr(hir_vec![],
placer_expr, placer_expr,
e.span, e.span,
hir::PopUnstableBlock, hir::PopUnstableBlock,
ThinVec::new()); ThinVec::new()));
mk_stmt_let(self, placer_ident, placer_expr) mk_stmt_let(self, placer_ident, placer_expr)
}; };
@ -1013,7 +1013,7 @@ impl<'a> LoweringContext<'a> {
// let p_ptr = Place::pointer(&mut place); // let p_ptr = Place::pointer(&mut place);
let (s3, p_ptr_binding) = { let (s3, p_ptr_binding) = {
let agent = self.expr_ident(e.span, place_ident, place_binding); let agent = P(self.expr_ident(e.span, place_ident, place_binding));
let args = hir_vec![self.expr_mut_addr_of(e.span, agent)]; let args = hir_vec![self.expr_mut_addr_of(e.span, agent)];
let call = make_call(self, &place_pointer, args); let call = make_call(self, &place_pointer, args);
mk_stmt_let(self, p_ptr_ident, call) mk_stmt_let(self, p_ptr_ident, call)
@ -1021,11 +1021,11 @@ impl<'a> LoweringContext<'a> {
// pop_unsafe!(EXPR)); // pop_unsafe!(EXPR));
let pop_unsafe_expr = { let pop_unsafe_expr = {
let value_expr = self.signal_block_expr(hir_vec![], let value_expr = P(self.signal_block_expr(hir_vec![],
value_expr, value_expr,
e.span, e.span,
hir::PopUnstableBlock, hir::PopUnstableBlock,
ThinVec::new()); ThinVec::new()));
self.signal_block_expr(hir_vec![], self.signal_block_expr(hir_vec![],
value_expr, value_expr,
e.span, e.span,
@ -1047,11 +1047,11 @@ impl<'a> LoweringContext<'a> {
let place = self.expr_ident(e.span, place_ident, place_binding); let place = self.expr_ident(e.span, place_ident, place_binding);
let call = make_call(self, &inplace_finalize, hir_vec![place]); let call = make_call(self, &inplace_finalize, hir_vec![place]);
self.signal_block_expr(hir_vec![call_move_val_init], P(self.signal_block_expr(hir_vec![call_move_val_init],
call, call,
e.span, e.span,
hir::PushUnsafeBlock(hir::CompilerGenerated), hir::PushUnsafeBlock(hir::CompilerGenerated),
ThinVec::new()) ThinVec::new()))
}; };
return self.signal_block_expr(hir_vec![s1, s2, s3], return self.signal_block_expr(hir_vec![s1, s2, s3],
@ -1065,15 +1065,15 @@ impl<'a> LoweringContext<'a> {
hir::ExprArray(exprs.iter().map(|x| self.lower_expr(x)).collect()) hir::ExprArray(exprs.iter().map(|x| self.lower_expr(x)).collect())
} }
ExprKind::Repeat(ref expr, ref count) => { ExprKind::Repeat(ref expr, ref count) => {
let expr = self.lower_expr(expr); let expr = P(self.lower_expr(expr));
let count = self.lower_expr(count); let count = P(self.lower_expr(count));
hir::ExprRepeat(expr, count) hir::ExprRepeat(expr, count)
} }
ExprKind::Tup(ref elts) => { ExprKind::Tup(ref elts) => {
hir::ExprTup(elts.iter().map(|x| self.lower_expr(x)).collect()) hir::ExprTup(elts.iter().map(|x| self.lower_expr(x)).collect())
} }
ExprKind::Call(ref f, ref args) => { ExprKind::Call(ref f, ref args) => {
let f = self.lower_expr(f); let f = P(self.lower_expr(f));
hir::ExprCall(f, args.iter().map(|x| self.lower_expr(x)).collect()) hir::ExprCall(f, args.iter().map(|x| self.lower_expr(x)).collect())
} }
ExprKind::MethodCall(i, ref tps, ref args) => { ExprKind::MethodCall(i, ref tps, ref args) => {
@ -1083,27 +1083,27 @@ impl<'a> LoweringContext<'a> {
} }
ExprKind::Binary(binop, ref lhs, ref rhs) => { ExprKind::Binary(binop, ref lhs, ref rhs) => {
let binop = self.lower_binop(binop); let binop = self.lower_binop(binop);
let lhs = self.lower_expr(lhs); let lhs = P(self.lower_expr(lhs));
let rhs = self.lower_expr(rhs); let rhs = P(self.lower_expr(rhs));
hir::ExprBinary(binop, lhs, rhs) hir::ExprBinary(binop, lhs, rhs)
} }
ExprKind::Unary(op, ref ohs) => { ExprKind::Unary(op, ref ohs) => {
let op = self.lower_unop(op); let op = self.lower_unop(op);
let ohs = self.lower_expr(ohs); let ohs = P(self.lower_expr(ohs));
hir::ExprUnary(op, ohs) hir::ExprUnary(op, ohs)
} }
ExprKind::Lit(ref l) => hir::ExprLit(P((**l).clone())), ExprKind::Lit(ref l) => hir::ExprLit(P((**l).clone())),
ExprKind::Cast(ref expr, ref ty) => { ExprKind::Cast(ref expr, ref ty) => {
let expr = self.lower_expr(expr); let expr = P(self.lower_expr(expr));
hir::ExprCast(expr, self.lower_ty(ty)) hir::ExprCast(expr, self.lower_ty(ty))
} }
ExprKind::Type(ref expr, ref ty) => { ExprKind::Type(ref expr, ref ty) => {
let expr = self.lower_expr(expr); let expr = P(self.lower_expr(expr));
hir::ExprType(expr, self.lower_ty(ty)) hir::ExprType(expr, self.lower_ty(ty))
} }
ExprKind::AddrOf(m, ref ohs) => { ExprKind::AddrOf(m, ref ohs) => {
let m = self.lower_mutability(m); let m = self.lower_mutability(m);
let ohs = self.lower_expr(ohs); let ohs = P(self.lower_expr(ohs));
hir::ExprAddrOf(m, ohs) hir::ExprAddrOf(m, ohs)
} }
// More complicated than you might expect because the else branch // More complicated than you might expect because the else branch
@ -1114,7 +1114,7 @@ impl<'a> LoweringContext<'a> {
ExprKind::IfLet(..) => { ExprKind::IfLet(..) => {
// wrap the if-let expr in a block // wrap the if-let expr in a block
let span = els.span; let span = els.span;
let els = self.lower_expr(els); let els = P(self.lower_expr(els));
let id = self.next_id(); let id = self.next_id();
let blk = P(hir::Block { let blk = P(hir::Block {
stmts: hir_vec![], stmts: hir_vec![],
@ -1123,23 +1123,23 @@ impl<'a> LoweringContext<'a> {
rules: hir::DefaultBlock, rules: hir::DefaultBlock,
span: span, span: span,
}); });
self.expr_block(blk, ThinVec::new()) P(self.expr_block(blk, ThinVec::new()))
} }
_ => self.lower_expr(els), _ => P(self.lower_expr(els)),
} }
}); });
hir::ExprIf(self.lower_expr(cond), self.lower_block(blk), else_opt) hir::ExprIf(P(self.lower_expr(cond)), self.lower_block(blk), else_opt)
} }
ExprKind::While(ref cond, ref body, opt_ident) => { ExprKind::While(ref cond, ref body, opt_ident) => {
hir::ExprWhile(self.lower_expr(cond), self.lower_block(body), hir::ExprWhile(P(self.lower_expr(cond)), self.lower_block(body),
self.lower_opt_sp_ident(opt_ident)) self.lower_opt_sp_ident(opt_ident))
} }
ExprKind::Loop(ref body, opt_ident) => { ExprKind::Loop(ref body, opt_ident) => {
hir::ExprLoop(self.lower_block(body), self.lower_opt_sp_ident(opt_ident)) hir::ExprLoop(self.lower_block(body), self.lower_opt_sp_ident(opt_ident))
} }
ExprKind::Match(ref expr, ref arms) => { ExprKind::Match(ref expr, ref arms) => {
hir::ExprMatch(self.lower_expr(expr), hir::ExprMatch(P(self.lower_expr(expr)),
arms.iter().map(|x| self.lower_arm(x)).collect(), arms.iter().map(|x| self.lower_arm(x)).collect(),
hir::MatchSource::Normal) hir::MatchSource::Normal)
} }
@ -1147,33 +1147,33 @@ impl<'a> LoweringContext<'a> {
self.with_parent_def(e.id, |this| { self.with_parent_def(e.id, |this| {
hir::ExprClosure(this.lower_capture_clause(capture_clause), hir::ExprClosure(this.lower_capture_clause(capture_clause),
this.lower_fn_decl(decl), this.lower_fn_decl(decl),
this.lower_expr(body), P(this.lower_expr(body)),
fn_decl_span) fn_decl_span)
}) })
} }
ExprKind::Block(ref blk) => hir::ExprBlock(self.lower_block(blk)), ExprKind::Block(ref blk) => hir::ExprBlock(self.lower_block(blk)),
ExprKind::Assign(ref el, ref er) => { ExprKind::Assign(ref el, ref er) => {
hir::ExprAssign(self.lower_expr(el), self.lower_expr(er)) hir::ExprAssign(P(self.lower_expr(el)), P(self.lower_expr(er)))
} }
ExprKind::AssignOp(op, ref el, ref er) => { ExprKind::AssignOp(op, ref el, ref er) => {
hir::ExprAssignOp(self.lower_binop(op), hir::ExprAssignOp(self.lower_binop(op),
self.lower_expr(el), P(self.lower_expr(el)),
self.lower_expr(er)) P(self.lower_expr(er)))
} }
ExprKind::Field(ref el, ident) => { ExprKind::Field(ref el, ident) => {
hir::ExprField(self.lower_expr(el), respan(ident.span, ident.node.name)) hir::ExprField(P(self.lower_expr(el)), respan(ident.span, ident.node.name))
} }
ExprKind::TupField(ref el, ident) => { ExprKind::TupField(ref el, ident) => {
hir::ExprTupField(self.lower_expr(el), ident) hir::ExprTupField(P(self.lower_expr(el)), ident)
} }
ExprKind::Index(ref el, ref er) => { ExprKind::Index(ref el, ref er) => {
hir::ExprIndex(self.lower_expr(el), self.lower_expr(er)) hir::ExprIndex(P(self.lower_expr(el)), P(self.lower_expr(er)))
} }
ExprKind::Range(ref e1, ref e2, lims) => { ExprKind::Range(ref e1, ref e2, lims) => {
fn make_struct(this: &mut LoweringContext, fn make_struct(this: &mut LoweringContext,
ast_expr: &Expr, ast_expr: &Expr,
path: &[&str], path: &[&str],
fields: &[(&str, &P<Expr>)]) -> P<hir::Expr> { fields: &[(&str, &P<Expr>)]) -> hir::Expr {
let struct_path = this.std_path(ast_expr.span, let struct_path = this.std_path(ast_expr.span,
&iter::once(&"ops").chain(path) &iter::once(&"ops").chain(path)
.map(|s| *s) .map(|s| *s)
@ -1183,12 +1183,12 @@ impl<'a> LoweringContext<'a> {
this.expr_path(struct_path, ast_expr.attrs.clone()) this.expr_path(struct_path, ast_expr.attrs.clone())
} else { } else {
let fields = fields.into_iter().map(|&(s, e)| { let fields = fields.into_iter().map(|&(s, e)| {
let expr = this.lower_expr(&e); let expr = P(this.lower_expr(&e));
let signal_block = this.signal_block_expr(hir_vec![], let signal_block = P(this.signal_block_expr(hir_vec![],
expr, expr,
e.span, e.span,
hir::PopUnstableBlock, hir::PopUnstableBlock,
ThinVec::new()); ThinVec::new()));
this.field(Symbol::intern(s), signal_block, ast_expr.span) this.field(Symbol::intern(s), signal_block, ast_expr.span)
}).collect(); }).collect();
let attrs = ast_expr.attrs.clone(); let attrs = ast_expr.attrs.clone();
@ -1244,7 +1244,7 @@ impl<'a> LoweringContext<'a> {
} }
ExprKind::Break(opt_ident) => hir::ExprBreak(self.lower_opt_sp_ident(opt_ident)), ExprKind::Break(opt_ident) => hir::ExprBreak(self.lower_opt_sp_ident(opt_ident)),
ExprKind::Continue(opt_ident) => hir::ExprAgain(self.lower_opt_sp_ident(opt_ident)), ExprKind::Continue(opt_ident) => hir::ExprAgain(self.lower_opt_sp_ident(opt_ident)),
ExprKind::Ret(ref e) => hir::ExprRet(e.as_ref().map(|x| self.lower_expr(x))), ExprKind::Ret(ref e) => hir::ExprRet(e.as_ref().map(|x| P(self.lower_expr(x)))),
ExprKind::InlineAsm(ref asm) => { ExprKind::InlineAsm(ref asm) => {
let hir_asm = hir::InlineAsm { let hir_asm = hir::InlineAsm {
inputs: asm.inputs.iter().map(|&(ref c, _)| c.clone()).collect(), inputs: asm.inputs.iter().map(|&(ref c, _)| c.clone()).collect(),
@ -1272,20 +1272,19 @@ impl<'a> LoweringContext<'a> {
ExprKind::Struct(ref path, ref fields, ref maybe_expr) => { ExprKind::Struct(ref path, ref fields, ref maybe_expr) => {
hir::ExprStruct(P(self.lower_path(path)), hir::ExprStruct(P(self.lower_path(path)),
fields.iter().map(|x| self.lower_field(x)).collect(), fields.iter().map(|x| self.lower_field(x)).collect(),
maybe_expr.as_ref().map(|x| self.lower_expr(x))) maybe_expr.as_ref().map(|x| P(self.lower_expr(x))))
} }
ExprKind::Paren(ref ex) => { ExprKind::Paren(ref ex) => {
return self.lower_expr(ex).map(|mut ex| { let mut ex = self.lower_expr(ex);
// include parens in span, but only if it is a super-span. // include parens in span, but only if it is a super-span.
if e.span.contains(ex.span) { if e.span.contains(ex.span) {
ex.span = e.span; ex.span = e.span;
} }
// merge attributes into the inner expression. // merge attributes into the inner expression.
let mut attrs = e.attrs.clone(); let mut attrs = e.attrs.clone();
attrs.extend::<Vec<_>>(ex.attrs.into()); attrs.extend::<Vec<_>>(ex.attrs.into());
ex.attrs = attrs; ex.attrs = attrs;
ex return ex;
});
} }
// Desugar ExprIfLet // Desugar ExprIfLet
@ -1302,13 +1301,13 @@ impl<'a> LoweringContext<'a> {
// `<pat> => <body>` // `<pat> => <body>`
let pat_arm = { let pat_arm = {
let body = self.lower_block(body); let body = self.lower_block(body);
let body_expr = self.expr_block(body, ThinVec::new()); let body_expr = P(self.expr_block(body, ThinVec::new()));
let pat = self.lower_pat(pat); let pat = self.lower_pat(pat);
self.arm(hir_vec![pat], body_expr) self.arm(hir_vec![pat], body_expr)
}; };
// `[_ if <else_opt_if_cond> => <else_opt_if_body>,]` // `[_ if <else_opt_if_cond> => <else_opt_if_body>,]`
let mut else_opt = else_opt.as_ref().map(|e| self.lower_expr(e)); let mut else_opt = else_opt.as_ref().map(|e| P(self.lower_expr(e)));
let else_if_arms = { let else_if_arms = {
let mut arms = vec![]; let mut arms = vec![];
loop { loop {
@ -1322,7 +1321,7 @@ impl<'a> LoweringContext<'a> {
attrs: hir_vec![], attrs: hir_vec![],
pats: hir_vec![pat_under], pats: hir_vec![pat_under],
guard: Some(cond), guard: Some(cond),
body: self.expr_block(then, ThinVec::new()), body: P(self.expr_block(then, ThinVec::new())),
}); });
else_opt.map(|else_opt| (else_opt, true)) else_opt.map(|else_opt| (else_opt, true))
} }
@ -1362,7 +1361,7 @@ impl<'a> LoweringContext<'a> {
arms.extend(else_if_arms); arms.extend(else_if_arms);
arms.push(else_arm); arms.push(else_arm);
let sub_expr = self.lower_expr(sub_expr); let sub_expr = P(self.lower_expr(sub_expr));
// add attributes to the outer returned expr node // add attributes to the outer returned expr node
return self.expr(e.span, return self.expr(e.span,
hir::ExprMatch(sub_expr, hir::ExprMatch(sub_expr,
@ -1388,7 +1387,7 @@ impl<'a> LoweringContext<'a> {
// `<pat> => <body>` // `<pat> => <body>`
let pat_arm = { let pat_arm = {
let body = self.lower_block(body); let body = self.lower_block(body);
let body_expr = self.expr_block(body, ThinVec::new()); let body_expr = P(self.expr_block(body, ThinVec::new()));
let pat = self.lower_pat(pat); let pat = self.lower_pat(pat);
self.arm(hir_vec![pat], body_expr) self.arm(hir_vec![pat], body_expr)
}; };
@ -1402,7 +1401,7 @@ impl<'a> LoweringContext<'a> {
// `match <sub_expr> { ... }` // `match <sub_expr> { ... }`
let arms = hir_vec![pat_arm, break_arm]; let arms = hir_vec![pat_arm, break_arm];
let sub_expr = self.lower_expr(sub_expr); let sub_expr = P(self.lower_expr(sub_expr));
let match_expr = self.expr(e.span, let match_expr = self.expr(e.span,
hir::ExprMatch(sub_expr, hir::ExprMatch(sub_expr,
arms, arms,
@ -1410,11 +1409,11 @@ impl<'a> LoweringContext<'a> {
ThinVec::new()); ThinVec::new());
// `[opt_ident]: loop { ... }` // `[opt_ident]: loop { ... }`
let loop_block = self.block_expr(match_expr); let loop_block = P(self.block_expr(P(match_expr)));
let loop_expr = hir::ExprLoop(loop_block, self.lower_opt_sp_ident(opt_ident)); let loop_expr = hir::ExprLoop(loop_block, self.lower_opt_sp_ident(opt_ident));
// add attributes to the outer returned expr node // add attributes to the outer returned expr node
let attrs = e.attrs.clone(); let attrs = e.attrs.clone();
return P(hir::Expr { id: e.id, node: loop_expr, span: e.span, attrs: attrs }); return hir::Expr { id: e.id, node: loop_expr, span: e.span, attrs: attrs };
} }
// Desugar ExprForLoop // Desugar ExprForLoop
@ -1471,19 +1470,21 @@ impl<'a> LoweringContext<'a> {
// `match ::std::iter::Iterator::next(&mut iter) { ... }` // `match ::std::iter::Iterator::next(&mut iter) { ... }`
let match_expr = { let match_expr = {
let next_path = self.std_path(e.span, &["iter", "Iterator", "next"]); let next_path = self.std_path(e.span, &["iter", "Iterator", "next"]);
let iter = self.expr_ident(e.span, iter, iter_pat.id); let iter = P(self.expr_ident(e.span, iter, iter_pat.id));
let ref_mut_iter = self.expr_mut_addr_of(e.span, iter); let ref_mut_iter = self.expr_mut_addr_of(e.span, iter);
let next_path = self.expr_path(next_path, ThinVec::new()); let next_path = self.expr_path(next_path, ThinVec::new());
let next_expr = self.expr_call(e.span, next_path, hir_vec![ref_mut_iter]); let next_expr = P(self.expr_call(e.span, next_path,
hir_vec![ref_mut_iter]));
let arms = hir_vec![pat_arm, break_arm]; let arms = hir_vec![pat_arm, break_arm];
self.expr(e.span, P(self.expr(e.span,
hir::ExprMatch(next_expr, arms, hir::MatchSource::ForLoopDesugar), hir::ExprMatch(next_expr, arms,
ThinVec::new()) hir::MatchSource::ForLoopDesugar),
ThinVec::new()))
}; };
// `[opt_ident]: loop { ... }` // `[opt_ident]: loop { ... }`
let loop_block = self.block_expr(match_expr); let loop_block = P(self.block_expr(match_expr));
let loop_expr = hir::ExprLoop(loop_block, self.lower_opt_sp_ident(opt_ident)); let loop_expr = hir::ExprLoop(loop_block, self.lower_opt_sp_ident(opt_ident));
let loop_expr = P(hir::Expr { let loop_expr = P(hir::Expr {
id: e.id, id: e.id,
@ -1501,13 +1502,13 @@ impl<'a> LoweringContext<'a> {
&["iter", "IntoIterator", "into_iter"]); &["iter", "IntoIterator", "into_iter"]);
let into_iter = self.expr_path(into_iter_path, ThinVec::new()); let into_iter = self.expr_path(into_iter_path, ThinVec::new());
self.expr_call(e.span, into_iter, hir_vec![head]) P(self.expr_call(e.span, into_iter, hir_vec![head]))
}; };
let match_expr = self.expr_match(e.span, let match_expr = P(self.expr_match(e.span,
into_iter_expr, into_iter_expr,
hir_vec![iter_arm], hir_vec![iter_arm],
hir::MatchSource::ForLoopDesugar); hir::MatchSource::ForLoopDesugar));
// `{ let _result = ...; _result }` // `{ let _result = ...; _result }`
// underscore prevents an unused_variables lint if the head diverges // underscore prevents an unused_variables lint if the head diverges
@ -1515,8 +1516,8 @@ impl<'a> LoweringContext<'a> {
let (let_stmt, let_stmt_binding) = let (let_stmt, let_stmt_binding) =
self.stmt_let(e.span, false, result_ident, match_expr); self.stmt_let(e.span, false, result_ident, match_expr);
let result = self.expr_ident(e.span, result_ident, let_stmt_binding); let result = P(self.expr_ident(e.span, result_ident, let_stmt_binding));
let block = self.block_all(e.span, hir_vec![let_stmt], Some(result)); let block = P(self.block_all(e.span, hir_vec![let_stmt], Some(result)));
// add the attributes to the outer returned expr node // add the attributes to the outer returned expr node
return self.expr_block(block, e.attrs.clone()); return self.expr_block(block, e.attrs.clone());
} }
@ -1536,7 +1537,7 @@ impl<'a> LoweringContext<'a> {
// { Carrier::translate( { <expr> } ) } // { Carrier::translate( { <expr> } ) }
let discr = { let discr = {
// expand <expr> // expand <expr>
let sub_expr = self.lower_expr(sub_expr); let sub_expr = P(self.lower_expr(sub_expr));
let sub_expr = self.signal_block_expr(hir_vec![], let sub_expr = self.signal_block_expr(hir_vec![],
sub_expr, sub_expr,
e.span, e.span,
@ -1545,20 +1546,20 @@ impl<'a> LoweringContext<'a> {
let path = self.std_path(e.span, &["ops", "Carrier", "translate"]); let path = self.std_path(e.span, &["ops", "Carrier", "translate"]);
let path = self.expr_path(path, ThinVec::new()); let path = self.expr_path(path, ThinVec::new());
let call = self.expr_call(e.span, path, hir_vec![sub_expr]); let call = P(self.expr_call(e.span, path, hir_vec![sub_expr]));
self.signal_block_expr(hir_vec![], P(self.signal_block_expr(hir_vec![],
call, call,
e.span, e.span,
hir::PushUnstableBlock, hir::PushUnstableBlock,
ThinVec::new()) ThinVec::new()))
}; };
// Ok(val) => val // Ok(val) => val
let ok_arm = { let ok_arm = {
let val_ident = self.str_to_ident("val"); let val_ident = self.str_to_ident("val");
let val_pat = self.pat_ident(e.span, val_ident); let val_pat = self.pat_ident(e.span, val_ident);
let val_expr = self.expr_ident(e.span, val_ident, val_pat.id); let val_expr = P(self.expr_ident(e.span, val_ident, val_pat.id));
let ok_pat = self.pat_ok(e.span, val_pat); let ok_pat = self.pat_ok(e.span, val_pat);
self.arm(hir_vec![ok_pat], val_expr) self.arm(hir_vec![ok_pat], val_expr)
@ -1578,15 +1579,16 @@ impl<'a> LoweringContext<'a> {
let from_err_expr = { let from_err_expr = {
let path = self.std_path(e.span, &["ops", "Carrier", "from_error"]); let path = self.std_path(e.span, &["ops", "Carrier", "from_error"]);
let from_err = self.expr_path(path, ThinVec::new()); let from_err = self.expr_path(path, ThinVec::new());
self.expr_call(e.span, from_err, hir_vec![from_expr]) P(self.expr_call(e.span, from_err, hir_vec![from_expr]))
}; };
let ret_expr = self.expr(e.span, let ret_expr = P(self.expr(e.span,
hir::Expr_::ExprRet(Some(from_err_expr)), hir::Expr_::ExprRet(Some(from_err_expr)),
ThinVec::new()); ThinVec::new()));
let ret_stmt = self.stmt_expr(ret_expr); let ret_stmt = self.stmt_expr(ret_expr);
let block = self.signal_block_stmt(ret_stmt, e.span, let block = P(self.signal_block_stmt(ret_stmt, e.span,
hir::PushUnstableBlock, ThinVec::new()); hir::PushUnstableBlock,
ThinVec::new()));
let err_pat = self.pat_err(e.span, err_local); let err_pat = self.pat_err(e.span, err_local);
self.arm(hir_vec![err_pat], block) self.arm(hir_vec![err_pat], block)
@ -1600,7 +1602,7 @@ impl<'a> LoweringContext<'a> {
}, },
span: e.span, span: e.span,
attrs: e.attrs.clone(), attrs: e.attrs.clone(),
}) }
} }
fn lower_stmt(&mut self, s: &Stmt) -> hir::Stmt { fn lower_stmt(&mut self, s: &Stmt) -> hir::Stmt {
@ -1621,13 +1623,13 @@ impl<'a> LoweringContext<'a> {
}, },
StmtKind::Expr(ref e) => { StmtKind::Expr(ref e) => {
Spanned { Spanned {
node: hir::StmtExpr(self.lower_expr(e), s.id), node: hir::StmtExpr(P(self.lower_expr(e)), s.id),
span: s.span, span: s.span,
} }
} }
StmtKind::Semi(ref e) => { StmtKind::Semi(ref e) => {
Spanned { Spanned {
node: hir::StmtSemi(self.lower_expr(e), s.id), node: hir::StmtSemi(P(self.lower_expr(e)), s.id),
span: s.span, span: s.span,
} }
} }
@ -1721,15 +1723,15 @@ impl<'a> LoweringContext<'a> {
} }
fn expr_break(&mut self, span: Span, attrs: ThinVec<Attribute>) -> P<hir::Expr> { fn expr_break(&mut self, span: Span, attrs: ThinVec<Attribute>) -> P<hir::Expr> {
self.expr(span, hir::ExprBreak(None), attrs) P(self.expr(span, hir::ExprBreak(None), attrs))
} }
fn expr_call(&mut self, span: Span, e: P<hir::Expr>, args: hir::HirVec<P<hir::Expr>>) fn expr_call(&mut self, span: Span, e: P<hir::Expr>, args: hir::HirVec<hir::Expr>)
-> P<hir::Expr> { -> hir::Expr {
self.expr(span, hir::ExprCall(e, args), ThinVec::new()) self.expr(span, hir::ExprCall(e, args), ThinVec::new())
} }
fn expr_ident(&mut self, span: Span, id: Name, binding: NodeId) -> P<hir::Expr> { fn expr_ident(&mut self, span: Span, id: Name, binding: NodeId) -> hir::Expr {
let expr_path = hir::ExprPath(None, self.path_ident(span, id)); let expr_path = hir::ExprPath(None, self.path_ident(span, id));
let expr = self.expr(span, expr_path, ThinVec::new()); let expr = self.expr(span, expr_path, ThinVec::new());
@ -1742,13 +1744,13 @@ impl<'a> LoweringContext<'a> {
expr expr
} }
fn expr_mut_addr_of(&mut self, span: Span, e: P<hir::Expr>) -> P<hir::Expr> { fn expr_mut_addr_of(&mut self, span: Span, e: P<hir::Expr>) -> hir::Expr {
self.expr(span, hir::ExprAddrOf(hir::MutMutable, e), ThinVec::new()) self.expr(span, hir::ExprAddrOf(hir::MutMutable, e), ThinVec::new())
} }
fn expr_path(&mut self, path: hir::Path, attrs: ThinVec<Attribute>) -> P<hir::Expr> { fn expr_path(&mut self, path: hir::Path, attrs: ThinVec<Attribute>) -> P<hir::Expr> {
let def = self.resolver.resolve_generated_global_path(&path, true); let def = self.resolver.resolve_generated_global_path(&path, true);
let expr = self.expr(path.span, hir::ExprPath(None, path), attrs); let expr = P(self.expr(path.span, hir::ExprPath(None, path), attrs));
self.resolver.record_resolution(expr.id, def); self.resolver.record_resolution(expr.id, def);
expr expr
} }
@ -1758,16 +1760,16 @@ impl<'a> LoweringContext<'a> {
arg: P<hir::Expr>, arg: P<hir::Expr>,
arms: hir::HirVec<hir::Arm>, arms: hir::HirVec<hir::Arm>,
source: hir::MatchSource) source: hir::MatchSource)
-> P<hir::Expr> { -> hir::Expr {
self.expr(span, hir::ExprMatch(arg, arms, source), ThinVec::new()) self.expr(span, hir::ExprMatch(arg, arms, source), ThinVec::new())
} }
fn expr_block(&mut self, b: P<hir::Block>, attrs: ThinVec<Attribute>) -> P<hir::Expr> { fn expr_block(&mut self, b: P<hir::Block>, attrs: ThinVec<Attribute>) -> hir::Expr {
self.expr(b.span, hir::ExprBlock(b), attrs) self.expr(b.span, hir::ExprBlock(b), attrs)
} }
fn expr_tuple(&mut self, sp: Span, exprs: hir::HirVec<P<hir::Expr>>) -> P<hir::Expr> { fn expr_tuple(&mut self, sp: Span, exprs: hir::HirVec<hir::Expr>) -> P<hir::Expr> {
self.expr(sp, hir::ExprTup(exprs), ThinVec::new()) P(self.expr(sp, hir::ExprTup(exprs), ThinVec::new()))
} }
fn expr_struct(&mut self, fn expr_struct(&mut self,
@ -1777,18 +1779,18 @@ impl<'a> LoweringContext<'a> {
e: Option<P<hir::Expr>>, e: Option<P<hir::Expr>>,
attrs: ThinVec<Attribute>) -> P<hir::Expr> { attrs: ThinVec<Attribute>) -> P<hir::Expr> {
let def = self.resolver.resolve_generated_global_path(&path, false); let def = self.resolver.resolve_generated_global_path(&path, false);
let expr = self.expr(sp, hir::ExprStruct(P(path), fields, e), attrs); let expr = P(self.expr(sp, hir::ExprStruct(P(path), fields, e), attrs));
self.resolver.record_resolution(expr.id, def); self.resolver.record_resolution(expr.id, def);
expr expr
} }
fn expr(&mut self, span: Span, node: hir::Expr_, attrs: ThinVec<Attribute>) -> P<hir::Expr> { fn expr(&mut self, span: Span, node: hir::Expr_, attrs: ThinVec<Attribute>) -> hir::Expr {
P(hir::Expr { hir::Expr {
id: self.next_id(), id: self.next_id(),
node: node, node: node,
span: span, span: span,
attrs: attrs, attrs: attrs,
}) }
} }
fn stmt_let(&mut self, sp: Span, mutbl: bool, ident: Name, ex: P<hir::Expr>) fn stmt_let(&mut self, sp: Span, mutbl: bool, ident: Name, ex: P<hir::Expr>)
@ -1820,19 +1822,19 @@ impl<'a> LoweringContext<'a> {
} }
} }
fn block_expr(&mut self, expr: P<hir::Expr>) -> P<hir::Block> { fn block_expr(&mut self, expr: P<hir::Expr>) -> hir::Block {
self.block_all(expr.span, hir::HirVec::new(), Some(expr)) self.block_all(expr.span, hir::HirVec::new(), Some(expr))
} }
fn block_all(&mut self, span: Span, stmts: hir::HirVec<hir::Stmt>, expr: Option<P<hir::Expr>>) fn block_all(&mut self, span: Span, stmts: hir::HirVec<hir::Stmt>, expr: Option<P<hir::Expr>>)
-> P<hir::Block> { -> hir::Block {
P(hir::Block { hir::Block {
stmts: stmts, stmts: stmts,
expr: expr, expr: expr,
id: self.next_id(), id: self.next_id(),
rules: hir::DefaultBlock, rules: hir::DefaultBlock,
span: span, span: span,
}) }
} }
fn pat_ok(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> { fn pat_ok(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
@ -1972,7 +1974,7 @@ impl<'a> LoweringContext<'a> {
span: Span, span: Span,
rule: hir::BlockCheckMode, rule: hir::BlockCheckMode,
attrs: ThinVec<Attribute>) attrs: ThinVec<Attribute>)
-> P<hir::Expr> { -> hir::Expr {
let id = self.next_id(); let id = self.next_id();
let block = P(hir::Block { let block = P(hir::Block {
rules: rule, rules: rule,
@ -1989,7 +1991,7 @@ impl<'a> LoweringContext<'a> {
span: Span, span: Span,
rule: hir::BlockCheckMode, rule: hir::BlockCheckMode,
attrs: ThinVec<Attribute>) attrs: ThinVec<Attribute>)
-> P<hir::Expr> { -> hir::Expr {
let id = self.next_id(); let id = self.next_id();
let block = P(hir::Block { let block = P(hir::Block {
rules: rule, rules: rule,

10
src/librustc/hir/mod.rs
View File

@ -867,12 +867,12 @@ pub enum Expr_ {
/// A `box x` expression. /// A `box x` expression.
ExprBox(P<Expr>), ExprBox(P<Expr>),
/// An array (`[a, b, c, d]`) /// An array (`[a, b, c, d]`)
ExprArray(HirVec<P<Expr>>), ExprArray(HirVec<Expr>),
/// A function call /// A function call
/// ///
/// The first field resolves to the function itself (usually an `ExprPath`), /// The first field resolves to the function itself (usually an `ExprPath`),
/// and the second field is the list of arguments /// and the second field is the list of arguments
ExprCall(P<Expr>, HirVec<P<Expr>>), ExprCall(P<Expr>, HirVec<Expr>),
/// A method call (`x.foo::<Bar, Baz>(a, b, c, d)`) /// A method call (`x.foo::<Bar, Baz>(a, b, c, d)`)
/// ///
/// The `Spanned<Name>` is the identifier for the method name. /// The `Spanned<Name>` is the identifier for the method name.
@ -885,9 +885,9 @@ pub enum Expr_ {
/// ///
/// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as /// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
/// `ExprMethodCall(foo, [Bar, Baz], [x, a, b, c, d])`. /// `ExprMethodCall(foo, [Bar, Baz], [x, a, b, c, d])`.
ExprMethodCall(Spanned<Name>, HirVec<P<Ty>>, HirVec<P<Expr>>), ExprMethodCall(Spanned<Name>, HirVec<P<Ty>>, HirVec<Expr>),
/// A tuple (`(a, b, c ,d)`) /// A tuple (`(a, b, c ,d)`)
ExprTup(HirVec<P<Expr>>), ExprTup(HirVec<Expr>),
/// A binary operation (For example: `a + b`, `a * b`) /// A binary operation (For example: `a + b`, `a * b`)
ExprBinary(BinOp, P<Expr>, P<Expr>), ExprBinary(BinOp, P<Expr>, P<Expr>),
/// A unary operation (For example: `!x`, `*x`) /// A unary operation (For example: `!x`, `*x`)
@ -951,7 +951,7 @@ pub enum Expr_ {
ExprRet(Option<P<Expr>>), ExprRet(Option<P<Expr>>),
/// Inline assembly (from `asm!`), with its outputs and inputs. /// Inline assembly (from `asm!`), with its outputs and inputs.
ExprInlineAsm(P<InlineAsm>, HirVec<P<Expr>>, HirVec<P<Expr>>), ExprInlineAsm(P<InlineAsm>, HirVec<Expr>, HirVec<Expr>),
/// A struct or struct-like variant literal expression. /// A struct or struct-like variant literal expression.
/// ///

24
src/librustc/hir/print.rs
View File

@ -452,7 +452,7 @@ impl<'a> State<'a> {
self.end() self.end()
} }
pub fn commasep_exprs(&mut self, b: Breaks, exprs: &[P<hir::Expr>]) -> io::Result<()> { pub fn commasep_exprs(&mut self, b: Breaks, exprs: &[hir::Expr]) -> io::Result<()> {
self.commasep_cmnt(b, exprs, |s, e| s.print_expr(&e), |e| e.span) self.commasep_cmnt(b, exprs, |s, e| s.print_expr(&e), |e| e.span)
} }
@ -1200,7 +1200,7 @@ impl<'a> State<'a> {
} }
fn print_call_post(&mut self, args: &[P<hir::Expr>]) -> io::Result<()> { fn print_call_post(&mut self, args: &[hir::Expr]) -> io::Result<()> {
self.popen()?; self.popen()?;
self.commasep_exprs(Inconsistent, args)?; self.commasep_exprs(Inconsistent, args)?;
self.pclose() self.pclose()
@ -1218,10 +1218,10 @@ impl<'a> State<'a> {
Ok(()) Ok(())
} }
fn print_expr_vec(&mut self, exprs: &[P<hir::Expr>]) -> io::Result<()> { fn print_expr_vec(&mut self, exprs: &[hir::Expr]) -> io::Result<()> {
self.ibox(indent_unit)?; self.ibox(indent_unit)?;
word(&mut self.s, "[")?; word(&mut self.s, "[")?;
self.commasep_exprs(Inconsistent, &exprs[..])?; self.commasep_exprs(Inconsistent, exprs)?;
word(&mut self.s, "]")?; word(&mut self.s, "]")?;
self.end() self.end()
} }
@ -1274,16 +1274,16 @@ impl<'a> State<'a> {
Ok(()) Ok(())
} }
fn print_expr_tup(&mut self, exprs: &[P<hir::Expr>]) -> io::Result<()> { fn print_expr_tup(&mut self, exprs: &[hir::Expr]) -> io::Result<()> {
self.popen()?; self.popen()?;
self.commasep_exprs(Inconsistent, &exprs[..])?; self.commasep_exprs(Inconsistent, exprs)?;
if exprs.len() == 1 { if exprs.len() == 1 {
word(&mut self.s, ",")?; word(&mut self.s, ",")?;
} }
self.pclose() self.pclose()
} }
fn print_expr_call(&mut self, func: &hir::Expr, args: &[P<hir::Expr>]) -> io::Result<()> { fn print_expr_call(&mut self, func: &hir::Expr, args: &[hir::Expr]) -> io::Result<()> {
self.print_expr_maybe_paren(func)?; self.print_expr_maybe_paren(func)?;
self.print_call_post(args) self.print_call_post(args)
} }
@ -1291,7 +1291,7 @@ impl<'a> State<'a> {
fn print_expr_method_call(&mut self, fn print_expr_method_call(&mut self,
name: Spanned<ast::Name>, name: Spanned<ast::Name>,
tys: &[P<hir::Ty>], tys: &[P<hir::Ty>],
args: &[P<hir::Expr>]) args: &[hir::Expr])
-> io::Result<()> { -> io::Result<()> {
let base_args = &args[1..]; let base_args = &args[1..];
self.print_expr(&args[0])?; self.print_expr(&args[0])?;
@ -1340,7 +1340,7 @@ impl<'a> State<'a> {
self.print_expr(expr)?; self.print_expr(expr)?;
} }
hir::ExprArray(ref exprs) => { hir::ExprArray(ref exprs) => {
self.print_expr_vec(&exprs[..])?; self.print_expr_vec(exprs)?;
} }
hir::ExprRepeat(ref element, ref count) => { hir::ExprRepeat(ref element, ref count) => {
self.print_expr_repeat(&element, &count)?; self.print_expr_repeat(&element, &count)?;
@ -1349,13 +1349,13 @@ impl<'a> State<'a> {
self.print_expr_struct(path, &fields[..], wth)?; self.print_expr_struct(path, &fields[..], wth)?;
} }
hir::ExprTup(ref exprs) => { hir::ExprTup(ref exprs) => {
self.print_expr_tup(&exprs[..])?; self.print_expr_tup(exprs)?;
} }
hir::ExprCall(ref func, ref args) => { hir::ExprCall(ref func, ref args) => {
self.print_expr_call(&func, &args[..])?; self.print_expr_call(&func, args)?;
} }
hir::ExprMethodCall(name, ref tys, ref args) => { hir::ExprMethodCall(name, ref tys, ref args) => {
self.print_expr_method_call(name, &tys[..], &args[..])?; self.print_expr_method_call(name, &tys[..], args)?;
} }
hir::ExprBinary(op, ref lhs, ref rhs) => { hir::ExprBinary(op, ref lhs, ref rhs) => {
self.print_expr_binary(op, &lhs, &rhs)?; self.print_expr_binary(op, &lhs, &rhs)?;

2
src/librustc/middle/expr_use_visitor.rs
View File

@ -327,7 +327,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
self.delegate.consume(consume_id, consume_span, cmt, mode); self.delegate.consume(consume_id, consume_span, cmt, mode);
} }
fn consume_exprs(&mut self, exprs: &[P<hir::Expr>]) { fn consume_exprs(&mut self, exprs: &[hir::Expr]) {
for expr in exprs { for expr in exprs {
self.consume_expr(&expr); self.consume_expr(&expr);
} }

11
src/librustc/middle/liveness.rs
View File

@ -123,7 +123,6 @@ use std::io::prelude::*;
use std::io; use std::io;
use std::rc::Rc; use std::rc::Rc;
use syntax::ast::{self, NodeId}; use syntax::ast::{self, NodeId};
use syntax::ptr::P;
use syntax::symbol::keywords; use syntax::symbol::keywords;
use syntax_pos::Span; use syntax_pos::Span;
@ -902,7 +901,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
self.define_bindings_in_pat(&local.pat, succ) self.define_bindings_in_pat(&local.pat, succ)
} }
fn propagate_through_exprs(&mut self, exprs: &[P<Expr>], succ: LiveNode) fn propagate_through_exprs(&mut self, exprs: &[Expr], succ: LiveNode)
-> LiveNode { -> LiveNode {
exprs.iter().rev().fold(succ, |succ, expr| { exprs.iter().rev().fold(succ, |succ, expr| {
self.propagate_through_expr(&expr, succ) self.propagate_through_expr(&expr, succ)
@ -1087,7 +1086,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
// Uninteresting cases: just propagate in rev exec order // Uninteresting cases: just propagate in rev exec order
hir::ExprArray(ref exprs) => { hir::ExprArray(ref exprs) => {
self.propagate_through_exprs(&exprs[..], succ) self.propagate_through_exprs(exprs, succ)
} }
hir::ExprRepeat(ref element, ref count) => { hir::ExprRepeat(ref element, ref count) => {
@ -1111,7 +1110,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} else { } else {
succ succ
}; };
let succ = self.propagate_through_exprs(&args[..], succ); let succ = self.propagate_through_exprs(args, succ);
self.propagate_through_expr(&f, succ) self.propagate_through_expr(&f, succ)
} }
@ -1124,11 +1123,11 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} else { } else {
succ succ
}; };
self.propagate_through_exprs(&args[..], succ) self.propagate_through_exprs(args, succ)
} }
hir::ExprTup(ref exprs) => { hir::ExprTup(ref exprs) => {
self.propagate_through_exprs(&exprs[..], succ) self.propagate_through_exprs(exprs, succ)
} }
hir::ExprBinary(op, ref l, ref r) if op.node.is_lazy() => { hir::ExprBinary(op, ref l, ref r) if op.node.is_lazy() => {

2
src/librustc_const_eval/eval.rs
View File

@ -297,7 +297,7 @@ pub fn const_expr_to_pat<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
_ => bug!() _ => bug!()
}; };
let pats = args.iter() let pats = args.iter()
.map(|expr| const_expr_to_pat(tcx, &**expr, pat_id, span)) .map(|expr| const_expr_to_pat(tcx, &*expr, pat_id, span))
.collect::<Result<_, _>>()?; .collect::<Result<_, _>>()?;
PatKind::TupleStruct(path, pats, None) PatKind::TupleStruct(path, pats, None)
} }

9
src/librustc_typeck/check/callee.rs
View File

@ -17,7 +17,6 @@ use hir::print;
use rustc::{infer, traits}; use rustc::{infer, traits};
use rustc::ty::{self, LvaluePreference, Ty}; use rustc::ty::{self, LvaluePreference, Ty};
use syntax::symbol::Symbol; use syntax::symbol::Symbol;
use syntax::ptr::P;
use syntax_pos::Span; use syntax_pos::Span;
use rustc::hir; use rustc::hir;
@ -46,7 +45,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
pub fn check_call(&self, pub fn check_call(&self,
call_expr: &'gcx hir::Expr, call_expr: &'gcx hir::Expr,
callee_expr: &'gcx hir::Expr, callee_expr: &'gcx hir::Expr,
arg_exprs: &'gcx [P<hir::Expr>], arg_exprs: &'gcx [hir::Expr],
expected: Expectation<'tcx>) expected: Expectation<'tcx>)
-> Ty<'tcx> { -> Ty<'tcx> {
let original_callee_ty = self.check_expr(callee_expr); let original_callee_ty = self.check_expr(callee_expr);
@ -189,7 +188,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
fn confirm_builtin_call(&self, fn confirm_builtin_call(&self,
call_expr: &hir::Expr, call_expr: &hir::Expr,
callee_ty: Ty<'tcx>, callee_ty: Ty<'tcx>,
arg_exprs: &'gcx [P<hir::Expr>], arg_exprs: &'gcx [hir::Expr],
expected: Expectation<'tcx>) expected: Expectation<'tcx>)
-> Ty<'tcx> { -> Ty<'tcx> {
let error_fn_sig; let error_fn_sig;
@ -272,7 +271,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
fn confirm_deferred_closure_call(&self, fn confirm_deferred_closure_call(&self,
call_expr: &hir::Expr, call_expr: &hir::Expr,
arg_exprs: &'gcx [P<hir::Expr>], arg_exprs: &'gcx [hir::Expr],
expected: Expectation<'tcx>, expected: Expectation<'tcx>,
fn_sig: ty::FnSig<'tcx>) fn_sig: ty::FnSig<'tcx>)
-> Ty<'tcx> { -> Ty<'tcx> {
@ -299,7 +298,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
fn confirm_overloaded_call(&self, fn confirm_overloaded_call(&self,
call_expr: &hir::Expr, call_expr: &hir::Expr,
callee_expr: &'gcx hir::Expr, callee_expr: &'gcx hir::Expr,
arg_exprs: &'gcx [P<hir::Expr>], arg_exprs: &'gcx [hir::Expr],
expected: Expectation<'tcx>, expected: Expectation<'tcx>,
method_callee: ty::MethodCallee<'tcx>) method_callee: ty::MethodCallee<'tcx>)
-> Ty<'tcx> { -> Ty<'tcx> {

12
src/librustc_typeck/check/mod.rs
View File

@ -2409,7 +2409,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
sp: Span, sp: Span,
method_fn_ty: Ty<'tcx>, method_fn_ty: Ty<'tcx>,
callee_expr: &'gcx hir::Expr, callee_expr: &'gcx hir::Expr,
args_no_rcvr: &'gcx [P<hir::Expr>], args_no_rcvr: &'gcx [hir::Expr],
tuple_arguments: TupleArgumentsFlag, tuple_arguments: TupleArgumentsFlag,
expected: Expectation<'tcx>) expected: Expectation<'tcx>)
-> Ty<'tcx> { -> Ty<'tcx> {
@ -2448,7 +2448,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
sp: Span, sp: Span,
fn_inputs: &[Ty<'tcx>], fn_inputs: &[Ty<'tcx>],
expected_arg_tys: &[Ty<'tcx>], expected_arg_tys: &[Ty<'tcx>],
args: &'gcx [P<hir::Expr>], args: &'gcx [hir::Expr],
variadic: bool, variadic: bool,
tuple_arguments: TupleArgumentsFlag) { tuple_arguments: TupleArgumentsFlag) {
let tcx = self.tcx; let tcx = self.tcx;
@ -2822,7 +2822,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
fn check_method_call(&self, fn check_method_call(&self,
expr: &'gcx hir::Expr, expr: &'gcx hir::Expr,
method_name: Spanned<ast::Name>, method_name: Spanned<ast::Name>,
args: &'gcx [P<hir::Expr>], args: &'gcx [hir::Expr],
tps: &[P<hir::Ty>], tps: &[P<hir::Ty>],
expected: Expectation<'tcx>, expected: Expectation<'tcx>,
lvalue_pref: LvaluePreference) -> Ty<'tcx> { lvalue_pref: LvaluePreference) -> Ty<'tcx> {
@ -3670,10 +3670,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
self.check_block_with_expected(&b, expected) self.check_block_with_expected(&b, expected)
} }
hir::ExprCall(ref callee, ref args) => { hir::ExprCall(ref callee, ref args) => {
self.check_call(expr, &callee, &args[..], expected) self.check_call(expr, &callee, args, expected)
} }
hir::ExprMethodCall(name, ref tps, ref args) => { hir::ExprMethodCall(name, ref tps, ref args) => {
self.check_method_call(expr, name, &args[..], &tps[..], expected, lvalue_pref) self.check_method_call(expr, name, args, &tps[..], expected, lvalue_pref)
} }
hir::ExprCast(ref e, ref t) => { hir::ExprCast(ref e, ref t) => {
if let hir::TyArray(_, ref count_expr) = t.node { if let hir::TyArray(_, ref count_expr) = t.node {
@ -3728,7 +3728,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let result = if i == 0 { let result = if i == 0 {
self.try_coerce(e, e_ty, coerce_to) self.try_coerce(e, e_ty, coerce_to)
} else { } else {
let prev_elems = || args[..i].iter().map(|e| &**e); let prev_elems = || args[..i].iter().map(|e| &*e);
self.try_find_coercion_lub(&cause, prev_elems, unified, e, e_ty) self.try_find_coercion_lub(&cause, prev_elems, unified, e, e_ty)
}; };

6
src/librustc_typeck/check/regionck.rs
View File

@ -613,11 +613,11 @@ impl<'a, 'gcx, 'tcx, 'v> Visitor<'v> for RegionCtxt<'a, 'gcx, 'tcx> {
hir::ExprCall(ref callee, ref args) => { hir::ExprCall(ref callee, ref args) => {
if has_method_map { if has_method_map {
self.constrain_call(expr, Some(&callee), self.constrain_call(expr, Some(&callee),
args.iter().map(|e| &**e), false); args.iter().map(|e| &*e), false);
} else { } else {
self.constrain_callee(callee.id, expr, &callee); self.constrain_callee(callee.id, expr, &callee);
self.constrain_call(expr, None, self.constrain_call(expr, None,
args.iter().map(|e| &**e), false); args.iter().map(|e| &*e), false);
} }
intravisit::walk_expr(self, expr); intravisit::walk_expr(self, expr);
@ -625,7 +625,7 @@ impl<'a, 'gcx, 'tcx, 'v> Visitor<'v> for RegionCtxt<'a, 'gcx, 'tcx> {
hir::ExprMethodCall(.., ref args) => { hir::ExprMethodCall(.., ref args) => {
self.constrain_call(expr, Some(&args[0]), self.constrain_call(expr, Some(&args[0]),
args[1..].iter().map(|e| &**e), false); args[1..].iter().map(|e| &*e), false);
intravisit::walk_expr(self, expr); intravisit::walk_expr(self, expr);
} }