user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Also print type adjustments in the inspector

Browse source
This commit is contained in:
Oliver Schneider 2017-05-05 14:25:54 +02:00
parent 3b03891a4f
commit eb93058dd5
1 changed files with 30 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

59
clippy_lints/src/utils/inspector.rs
View file

@ -152,21 +152,22 @@ fn print_decl(cx: &LateContext, decl: &hir::Decl) {
fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {
let ind = " ".repeat(indent);
let ty = cx.tables.node_id_to_type(expr.id);
println!("{}+", ind);
println!("{}ty: {}", ind, cx.tables.expr_ty(expr));
println!("{}adjustments: {:?}", ind, cx.tables.adjustments.get(&expr.id));
match expr.node {
hir::ExprBox(ref e) => {
println!("{}Box, {}", ind, ty);
println!("{}Box", ind);
print_expr(cx, e, indent + 1);
},
hir::ExprArray(ref v) => {
println!("{}Array, {}", ind, ty);
println!("{}Array", ind);
for e in v {
print_expr(cx, e, indent + 1);
}
},
hir::ExprCall(ref func, ref args) => {
println!("{}Call, {}", ind, ty);
println!("{}Call", ind);
println!("{}function:", ind);
print_expr(cx, func, indent + 1);
println!("{}arguments:", ind);
@ -175,20 +176,20 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {
}
},
hir::ExprMethodCall(ref name, _, ref args) => {
println!("{}MethodCall, {}", ind, ty);
println!("{}MethodCall", ind);
println!("{}method name: {}", ind, name.node);
for arg in args {
print_expr(cx, arg, indent + 1);
}
},
hir::ExprTup(ref v) => {
println!("{}Tup, {}", ind, ty);
println!("{}Tup", ind);
for e in v {
print_expr(cx, e, indent + 1);
}
},
hir::ExprBinary(op, ref lhs, ref rhs) => {
println!("{}Binary, {}", ind, ty);
println!("{}Binary", ind);
println!("{}op: {:?}", ind, op.node);
println!("{}lhs:", ind);
print_expr(cx, lhs, indent + 1);
@ -196,26 +197,26 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {
print_expr(cx, rhs, indent + 1);
},
hir::ExprUnary(op, ref inner) => {
println!("{}Unary, {}", ind, ty);
println!("{}Unary", ind);
println!("{}op: {:?}", ind, op);
print_expr(cx, inner, indent + 1);
},
hir::ExprLit(ref lit) => {
println!("{}Lit, {}", ind, ty);
println!("{}Lit", ind);
println!("{}{:?}", ind, lit);
},
hir::ExprCast(ref e, ref target) => {
println!("{}Cast, {}", ind, ty);
println!("{}Cast", ind);
print_expr(cx, e, indent + 1);
println!("{}target type: {:?}", ind, target);
},
hir::ExprType(ref e, ref target) => {
println!("{}Type, {}", ind, ty);
println!("{}Type", ind);
print_expr(cx, e, indent + 1);
println!("{}target type: {:?}", ind, target);
},
hir::ExprIf(ref e, _, ref els) => {
println!("{}If, {}", ind, ty);
println!("{}If", ind);
println!("{}condition:", ind);
print_expr(cx, e, indent + 1);
if let Some(ref els) = *els {
@ -224,35 +225,35 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {
}
},
hir::ExprWhile(ref cond, _, _) => {
println!("{}While, {}", ind, ty);
println!("{}While", ind);
println!("{}condition:", ind);
print_expr(cx, cond, indent + 1);
},
hir::ExprLoop(..) => {
println!("{}Loop, {}", ind, ty);
println!("{}Loop", ind);
},
hir::ExprMatch(ref cond, _, ref source) => {
println!("{}Match, {}", ind, ty);
println!("{}Match", ind);
println!("{}condition:", ind);
print_expr(cx, cond, indent + 1);
println!("{}source: {:?}", ind, source);
},
hir::ExprClosure(ref clause, _, _, _) => {
println!("{}Closure, {}", ind, ty);
println!("{}Closure", ind);
println!("{}clause: {:?}", ind, clause);
},
hir::ExprBlock(_) => {
println!("{}Block, {}", ind, ty);
println!("{}Block", ind);
},
hir::ExprAssign(ref lhs, ref rhs) => {
println!("{}Assign, {}", ind, ty);
println!("{}Assign", ind);
println!("{}lhs:", ind);
print_expr(cx, lhs, indent + 1);
println!("{}rhs:", ind);
print_expr(cx, rhs, indent + 1);
},
hir::ExprAssignOp(ref binop, ref lhs, ref rhs) => {
println!("{}AssignOp, {}", ind, ty);
println!("{}AssignOp", ind);
println!("{}op: {:?}", ind, binop.node);
println!("{}lhs:", ind);
print_expr(cx, lhs, indent + 1);
@ -260,19 +261,19 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {
print_expr(cx, rhs, indent + 1);
},
hir::ExprField(ref e, ref name) => {
println!("{}Field, {}", ind, ty);
println!("{}Field", ind);
println!("{}field name: {}", ind, name.node);
println!("{}struct expr:", ind);
print_expr(cx, e, indent + 1);
},
hir::ExprTupField(ref e, ref idx) => {
println!("{}TupField, {}", ind, ty);
println!("{}TupField", ind);
println!("{}field index: {}", ind, idx.node);
println!("{}tuple expr:", ind);
print_expr(cx, e, indent + 1);
},
hir::ExprIndex(ref arr, ref idx) => {
println!("{}Index, {}", ind, ty);
println!("{}Index", ind);
println!("{}array expr:", ind);
print_expr(cx, arr, indent + 1);
println!("{}index expr:", ind);
@ -287,25 +288,25 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {
println!("{}seg: {:?}", ind, seg);
},
hir::ExprAddrOf(ref muta, ref e) => {
println!("{}AddrOf, {}", ind, ty);
println!("{}AddrOf", ind);
println!("mutability: {:?}", muta);
print_expr(cx, e, indent + 1);
},
hir::ExprBreak(_, ref e) => {
println!("{}Break, {}", ind, ty);
println!("{}Break", ind);
if let Some(ref e) = *e {
print_expr(cx, e, indent + 1);
}
},
hir::ExprAgain(_) => println!("{}Again, {}", ind, ty),
hir::ExprAgain(_) => println!("{}Again", ind),
hir::ExprRet(ref e) => {
println!("{}Ret, {}", ind, ty);
println!("{}Ret", ind);
if let Some(ref e) = *e {
print_expr(cx, e, indent + 1);
}
},
hir::ExprInlineAsm(_, ref input, ref output) => {
println!("{}InlineAsm, {}", ind, ty);
println!("{}InlineAsm", ind);
println!("{}inputs:", ind);
for e in input {
print_expr(cx, e, indent + 1);
@ -316,7 +317,7 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {
}
},
hir::ExprStruct(ref path, ref fields, ref base) => {
println!("{}Struct, {}", ind, ty);
println!("{}Struct", ind);
println!("{}path: {:?}", ind, path);
for field in fields {
println!("{}field \"{}\":", ind, field.name.node);
@ -328,7 +329,7 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {
}
},
hir::ExprRepeat(ref val, body_id) => {
println!("{}Repeat, {}", ind, ty);
println!("{}Repeat", ind);
println!("{}value:", ind);
print_expr(cx, val, indent + 1);
println!("{}repeat count:", ind);