rust-clippy/clippy_lints/src/utils/inspector.rs

524 lines
19 KiB
Rust
Raw Normal View History

//! checks for attributes
2018-05-30 08:15:50 +00:00
use crate::utils::get_attr;
2020-01-11 11:37:08 +00:00
use rustc::lint::{LateContext, LateLintPass, LintContext};
use rustc::session::Session;
2020-01-06 16:39:50 +00:00
use rustc_hir as hir;
use rustc_hir::print;
2020-01-11 11:37:08 +00:00
use rustc_session::{declare_lint_pass, declare_tool_lint};
use syntax::ast::Attribute;
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
/// **What it does:** Dumps every ast/hir node which has the `#[clippy::dump]`
/// attribute
///
/// **Example:**
/// ```rust,ignore
/// #[clippy::dump]
/// extern crate foo;
/// ```
///
/// prints
///
/// ```text
/// item `foo`
/// visibility inherited from outer item
/// extern crate dylib source: "/path/to/foo.so"
/// ```
pub DEEP_CODE_INSPECTION,
2018-03-29 11:41:53 +00:00
internal_warn,
"helper to dump info about code"
}
2019-04-08 20:43:55 +00:00
declare_lint_pass!(DeepCodeInspector => [DEEP_CODE_INSPECTION]);
2019-04-08 20:43:55 +00:00
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DeepCodeInspector {
2019-12-22 14:42:41 +00:00
fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item<'_>) {
if !has_attr(cx.sess(), &item.attrs) {
return;
}
2016-10-24 12:29:09 +00:00
print_item(cx, item);
}
2019-12-22 14:42:41 +00:00
fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ImplItem<'_>) {
if !has_attr(cx.sess(), &item.attrs) {
2016-10-24 12:29:09 +00:00
return;
}
2018-06-28 13:46:58 +00:00
println!("impl item `{}`", item.ident.name);
2018-07-02 17:07:12 +00:00
match item.vis.node {
hir::VisibilityKind::Public => println!("public"),
hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
hir::VisibilityKind::Restricted { ref path, .. } => println!(
2017-09-05 09:33:04 +00:00
"visible in module `{}`",
print::to_string(print::NO_ANN, |s| s.print_path(path, false))
),
2018-07-02 17:07:12 +00:00
hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
}
2016-10-24 12:29:09 +00:00
if item.defaultness.is_default() {
println!("default");
}
2019-09-27 15:16:06 +00:00
match item.kind {
hir::ImplItemKind::Const(_, body_id) => {
2016-10-24 12:29:09 +00:00
println!("associated constant");
print_expr(cx, &cx.tcx.hir().body(body_id).value, 1);
},
2016-10-24 12:29:09 +00:00
hir::ImplItemKind::Method(..) => println!("method"),
hir::ImplItemKind::TyAlias(_) => println!("associated type"),
hir::ImplItemKind::OpaqueTy(_) => println!("existential type"),
}
}
2017-08-09 07:30:56 +00:00
// fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx
// hir::TraitItem) {
2016-12-20 17:21:30 +00:00
// if !has_attr(&item.attrs) {
// return;
// }
// }
//
2017-08-09 07:30:56 +00:00
// fn check_variant(&mut self, cx: &LateContext<'a, 'tcx>, var: &'tcx
// hir::Variant, _:
// &hir::Generics) {
2016-12-20 17:21:30 +00:00
// if !has_attr(&var.node.attrs) {
// return;
// }
// }
//
2017-08-09 07:30:56 +00:00
// fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx
// hir::StructField) {
2016-12-20 17:21:30 +00:00
// if !has_attr(&field.attrs) {
// return;
// }
// }
//
2019-12-27 07:12:26 +00:00
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr<'_>) {
if !has_attr(cx.sess(), &expr.attrs) {
return;
}
2016-10-24 12:28:58 +00:00
print_expr(cx, expr, 0);
}
2019-12-27 07:12:26 +00:00
fn check_arm(&mut self, cx: &LateContext<'a, 'tcx>, arm: &'tcx hir::Arm<'_>) {
if !has_attr(cx.sess(), &arm.attrs) {
return;
}
2019-09-25 19:00:17 +00:00
print_pat(cx, &arm.pat, 1);
2016-10-24 12:28:58 +00:00
if let Some(ref guard) = arm.guard {
println!("guard:");
2018-09-02 07:38:25 +00:00
print_guard(cx, guard, 1);
2016-10-24 12:28:58 +00:00
}
println!("body:");
print_expr(cx, &arm.body, 1);
}
2019-12-27 07:12:26 +00:00
fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx hir::Stmt<'_>) {
2019-09-27 15:16:06 +00:00
if !has_attr(cx.sess(), stmt.kind.attrs()) {
return;
}
2019-09-27 15:16:06 +00:00
match stmt.kind {
hir::StmtKind::Local(ref local) => {
2019-02-13 21:06:19 +00:00
println!("local variable of type {}", cx.tables.node_type(local.hir_id));
println!("pattern:");
print_pat(cx, &local.pat, 0);
if let Some(ref e) = local.init {
println!("init expression:");
print_expr(cx, e, 0);
}
2019-01-20 10:49:45 +00:00
},
hir::StmtKind::Item(_) => println!("item decl"),
hir::StmtKind::Expr(ref e) | hir::StmtKind::Semi(ref e) => print_expr(cx, e, 0),
}
}
2017-08-09 07:30:56 +00:00
// fn check_foreign_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx
// hir::ForeignItem) {
2016-12-20 17:21:30 +00:00
// if !has_attr(&item.attrs) {
// return;
// }
// }
//
}
fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
get_attr(sess, attrs, "dump").count() > 0
}
2016-10-24 12:28:58 +00:00
#[allow(clippy::similar_names)]
#[allow(clippy::too_many_lines)]
2019-12-27 07:12:26 +00:00
fn print_expr(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, indent: usize) {
2016-10-24 12:28:58 +00:00
let ind = " ".repeat(indent);
println!("{}+", ind);
println!("{}ty: {}", ind, cx.tables.expr_ty(expr));
2017-08-15 09:10:49 +00:00
println!("{}adjustments: {:?}", ind, cx.tables.adjustments().get(expr.hir_id));
2019-09-27 15:16:06 +00:00
match expr.kind {
2018-07-12 07:30:57 +00:00
hir::ExprKind::Box(ref e) => {
println!("{}Box", ind);
2016-10-24 12:28:58 +00:00
print_expr(cx, e, indent + 1);
},
2019-12-27 07:12:26 +00:00
hir::ExprKind::Array(v) => {
println!("{}Array", ind);
2016-10-24 12:28:58 +00:00
for e in v {
print_expr(cx, e, indent + 1);
}
},
2019-12-27 07:12:26 +00:00
hir::ExprKind::Call(ref func, args) => {
println!("{}Call", ind);
2016-10-24 12:28:58 +00:00
println!("{}function:", ind);
print_expr(cx, func, indent + 1);
println!("{}arguments:", ind);
for arg in args {
print_expr(cx, arg, indent + 1);
}
},
2019-12-27 07:12:26 +00:00
hir::ExprKind::MethodCall(ref path, _, args) => {
println!("{}MethodCall", ind);
2018-06-28 13:46:58 +00:00
println!("{}method name: {}", ind, path.ident.name);
2016-10-24 12:28:58 +00:00
for arg in args {
print_expr(cx, arg, indent + 1);
}
},
2019-12-27 07:12:26 +00:00
hir::ExprKind::Tup(v) => {
println!("{}Tup", ind);
2016-10-24 12:28:58 +00:00
for e in v {
print_expr(cx, e, indent + 1);
}
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
println!("{}Binary", ind);
2016-10-24 12:28:58 +00:00
println!("{}op: {:?}", ind, op.node);
println!("{}lhs:", ind);
print_expr(cx, lhs, indent + 1);
println!("{}rhs:", ind);
print_expr(cx, rhs, indent + 1);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Unary(op, ref inner) => {
println!("{}Unary", ind);
2016-10-24 12:28:58 +00:00
println!("{}op: {:?}", ind, op);
print_expr(cx, inner, indent + 1);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Lit(ref lit) => {
println!("{}Lit", ind);
2016-10-24 12:28:58 +00:00
println!("{}{:?}", ind, lit);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Cast(ref e, ref target) => {
println!("{}Cast", ind);
2016-10-24 12:28:58 +00:00
print_expr(cx, e, indent + 1);
println!("{}target type: {:?}", ind, target);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Type(ref e, ref target) => {
println!("{}Type", ind);
2016-10-24 12:28:58 +00:00
print_expr(cx, e, indent + 1);
println!("{}target type: {:?}", ind, target);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Loop(..) => {
println!("{}Loop", ind);
2016-10-24 12:28:58 +00:00
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Match(ref cond, _, ref source) => {
println!("{}Match", ind);
2016-10-24 12:28:58 +00:00
println!("{}condition:", ind);
print_expr(cx, cond, indent + 1);
println!("{}source: {:?}", ind, source);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Closure(ref clause, _, _, _, _) => {
println!("{}Closure", ind);
2016-10-24 12:28:58 +00:00
println!("{}clause: {:?}", ind, clause);
},
hir::ExprKind::Yield(ref sub, _) => {
2017-08-30 08:54:24 +00:00
println!("{}Yield", ind);
print_expr(cx, sub, indent + 1);
2017-09-03 21:15:15 +00:00
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Block(_, _) => {
println!("{}Block", ind);
2016-10-24 12:28:58 +00:00
},
hir::ExprKind::Assign(ref lhs, ref rhs, _) => {
println!("{}Assign", ind);
2016-10-24 12:28:58 +00:00
println!("{}lhs:", ind);
print_expr(cx, lhs, indent + 1);
println!("{}rhs:", ind);
print_expr(cx, rhs, indent + 1);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::AssignOp(ref binop, ref lhs, ref rhs) => {
println!("{}AssignOp", ind);
2016-10-24 12:28:58 +00:00
println!("{}op: {:?}", ind, binop.node);
println!("{}lhs:", ind);
print_expr(cx, lhs, indent + 1);
println!("{}rhs:", ind);
print_expr(cx, rhs, indent + 1);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Field(ref e, ident) => {
println!("{}Field", ind);
2018-05-29 08:56:58 +00:00
println!("{}field name: {}", ind, ident.name);
2016-10-24 12:28:58 +00:00
println!("{}struct expr:", ind);
print_expr(cx, e, indent + 1);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Index(ref arr, ref idx) => {
println!("{}Index", ind);
2016-10-24 12:28:58 +00:00
println!("{}array expr:", ind);
print_expr(cx, arr, indent + 1);
println!("{}index expr:", ind);
print_expr(cx, idx, indent + 1);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
println!("{}Resolved Path, {:?}", ind, ty);
2016-10-24 12:28:58 +00:00
println!("{}path: {:?}", ind, path);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
println!("{}Relative Path, {:?}", ind, ty);
println!("{}seg: {:?}", ind, seg);
2016-12-20 17:21:30 +00:00
},
hir::ExprKind::AddrOf(kind, ref muta, ref e) => {
println!("{}AddrOf", ind);
println!("kind: {:?}", kind);
2016-10-24 12:28:58 +00:00
println!("mutability: {:?}", muta);
print_expr(cx, e, indent + 1);
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Break(_, ref e) => {
println!("{}Break", ind);
if let Some(ref e) = *e {
print_expr(cx, e, indent + 1);
}
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Continue(_) => println!("{}Again", ind),
hir::ExprKind::Ret(ref e) => {
println!("{}Ret", ind);
2016-10-24 12:28:58 +00:00
if let Some(ref e) = *e {
print_expr(cx, e, indent + 1);
}
},
hir::ExprKind::InlineAsm(ref asm) => {
let inputs = &asm.inputs_exprs;
let outputs = &asm.outputs_exprs;
println!("{}InlineAsm", ind);
2016-10-24 12:28:58 +00:00
println!("{}inputs:", ind);
for e in inputs.iter() {
2016-10-24 12:28:58 +00:00
print_expr(cx, e, indent + 1);
}
println!("{}outputs:", ind);
for e in outputs.iter() {
2016-10-24 12:28:58 +00:00
print_expr(cx, e, indent + 1);
}
},
2019-12-27 07:12:26 +00:00
hir::ExprKind::Struct(ref path, fields, ref base) => {
println!("{}Struct", ind);
2016-10-24 12:28:58 +00:00
println!("{}path: {:?}", ind, path);
for field in fields {
2018-05-29 08:56:58 +00:00
println!("{}field \"{}\":", ind, field.ident.name);
2016-10-24 12:28:58 +00:00
print_expr(cx, &field.expr, indent + 1);
}
if let Some(ref base) = *base {
println!("{}base:", ind);
print_expr(cx, base, indent + 1);
}
},
2018-07-12 07:30:57 +00:00
hir::ExprKind::Repeat(ref val, ref anon_const) => {
println!("{}Repeat", ind);
2016-10-24 12:28:58 +00:00
println!("{}value:", ind);
print_expr(cx, val, indent + 1);
println!("{}repeat count:", ind);
print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
2016-10-24 12:28:58 +00:00
},
2018-12-28 11:29:34 +00:00
hir::ExprKind::Err => {
println!("{}Err", ind);
},
hir::ExprKind::DropTemps(ref e) => {
2019-05-01 20:52:19 +00:00
println!("{}DropTemps", ind);
print_expr(cx, e, indent + 1);
},
2016-10-24 12:28:58 +00:00
}
}
2016-10-24 12:29:09 +00:00
2019-12-22 14:42:41 +00:00
fn print_item(cx: &LateContext<'_, '_>, item: &hir::Item<'_>) {
let did = cx.tcx.hir().local_def_id(item.hir_id);
println!("item `{}`", item.ident.name);
2018-07-02 17:07:12 +00:00
match item.vis.node {
hir::VisibilityKind::Public => println!("public"),
hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
hir::VisibilityKind::Restricted { ref path, .. } => println!(
2017-09-05 09:33:04 +00:00
"visible in module `{}`",
print::to_string(print::NO_ANN, |s| s.print_path(path, false))
),
2018-07-02 17:07:12 +00:00
hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
2016-10-24 12:29:09 +00:00
}
2019-09-27 15:16:06 +00:00
match item.kind {
2018-07-16 13:07:39 +00:00
hir::ItemKind::ExternCrate(ref _renamed_from) => {
let def_id = cx.tcx.hir().local_def_id(item.hir_id);
2017-09-12 12:26:40 +00:00
if let Some(crate_id) = cx.tcx.extern_mod_stmt_cnum(def_id) {
let source = cx.tcx.used_crate_source(crate_id);
if let Some(ref src) = source.dylib {
2016-10-24 12:29:09 +00:00
println!("extern crate dylib source: {:?}", src.0);
}
if let Some(ref src) = source.rlib {
2016-10-24 12:29:09 +00:00
println!("extern crate rlib source: {:?}", src.0);
}
} else {
println!("weird extern crate without a crate id");
}
2016-12-20 17:21:30 +00:00
},
2018-07-16 13:07:39 +00:00
hir::ItemKind::Use(ref path, ref kind) => println!("{:?}, {:?}", path, kind),
hir::ItemKind::Static(..) => println!("static item of type {:#?}", cx.tcx.type_of(did)),
hir::ItemKind::Const(..) => println!("const item of type {:#?}", cx.tcx.type_of(did)),
hir::ItemKind::Fn(..) => {
2017-04-27 12:00:35 +00:00
let item_ty = cx.tcx.type_of(did);
2016-11-18 12:21:07 +00:00
println!("function of type {:#?}", item_ty);
2016-10-24 12:29:09 +00:00
},
2018-07-16 13:07:39 +00:00
hir::ItemKind::Mod(..) => println!("module"),
hir::ItemKind::ForeignMod(ref fm) => println!("foreign module with abi: {}", fm.abi),
hir::ItemKind::GlobalAsm(ref asm) => println!("global asm: {:?}", asm),
hir::ItemKind::TyAlias(..) => {
2017-04-27 12:00:35 +00:00
println!("type alias for {:?}", cx.tcx.type_of(did));
2016-10-24 12:29:09 +00:00
},
hir::ItemKind::OpaqueTy(..) => {
2018-06-19 07:56:37 +00:00
println!("existential type with real type {:?}", cx.tcx.type_of(did));
},
2018-07-16 13:07:39 +00:00
hir::ItemKind::Enum(..) => {
2017-04-27 12:00:35 +00:00
println!("enum definition of type {:?}", cx.tcx.type_of(did));
2016-10-24 12:29:09 +00:00
},
2018-07-16 13:07:39 +00:00
hir::ItemKind::Struct(..) => {
2017-04-27 12:00:35 +00:00
println!("struct definition of type {:?}", cx.tcx.type_of(did));
2016-10-24 12:29:09 +00:00
},
2018-07-16 13:07:39 +00:00
hir::ItemKind::Union(..) => {
2017-04-27 12:00:35 +00:00
println!("union definition of type {:?}", cx.tcx.type_of(did));
2016-10-24 12:29:09 +00:00
},
2018-07-16 13:07:39 +00:00
hir::ItemKind::Trait(..) => {
2016-10-24 12:29:09 +00:00
println!("trait decl");
if cx.tcx.trait_is_auto(did) {
println!("trait is auto");
2016-10-24 12:29:09 +00:00
} else {
println!("trait is not auto");
2016-10-24 12:29:09 +00:00
}
},
2018-07-16 13:07:39 +00:00
hir::ItemKind::TraitAlias(..) => {
println!("trait alias");
2018-11-27 20:14:15 +00:00
},
2018-07-16 13:07:39 +00:00
hir::ItemKind::Impl(_, _, _, _, Some(ref _trait_ref), _, _) => {
println!("trait impl");
2016-10-24 12:29:09 +00:00
},
2018-07-16 13:07:39 +00:00
hir::ItemKind::Impl(_, _, _, _, None, _, _) => {
2016-10-24 12:29:09 +00:00
println!("impl");
},
}
}
#[allow(clippy::similar_names)]
#[allow(clippy::too_many_lines)]
2019-12-27 07:12:26 +00:00
fn print_pat(cx: &LateContext<'_, '_>, pat: &hir::Pat<'_>, indent: usize) {
2016-10-24 12:28:58 +00:00
let ind = " ".repeat(indent);
println!("{}+", ind);
2019-09-27 15:16:06 +00:00
match pat.kind {
2016-10-24 12:28:58 +00:00
hir::PatKind::Wild => println!("{}Wild", ind),
hir::PatKind::Binding(ref mode, .., ident, ref inner) => {
2016-10-24 12:28:58 +00:00
println!("{}Binding", ind);
println!("{}mode: {:?}", ind, mode);
2018-06-28 13:46:58 +00:00
println!("{}name: {}", ind, ident.name);
2016-10-24 12:28:58 +00:00
if let Some(ref inner) = *inner {
println!("{}inner:", ind);
print_pat(cx, inner, indent + 1);
}
},
2019-12-27 07:12:26 +00:00
hir::PatKind::Or(fields) => {
println!("{}Or", ind);
for field in fields {
print_pat(cx, field, indent + 1);
}
},
2019-12-27 07:12:26 +00:00
hir::PatKind::Struct(ref path, fields, ignore) => {
2016-10-24 12:28:58 +00:00
println!("{}Struct", ind);
2017-08-09 07:30:56 +00:00
println!(
"{}name: {}",
ind,
print::to_string(print::NO_ANN, |s| s.print_qpath(path, false))
);
2016-10-24 12:28:58 +00:00
println!("{}ignore leftover fields: {}", ind, ignore);
println!("{}fields:", ind);
for field in fields {
println!("{} field name: {}", ind, field.ident.name);
if field.is_shorthand {
2016-10-24 12:28:58 +00:00
println!("{} in shorthand notation", ind);
}
print_pat(cx, &field.pat, indent + 1);
2016-10-24 12:28:58 +00:00
}
},
2019-12-27 07:12:26 +00:00
hir::PatKind::TupleStruct(ref path, fields, opt_dots_position) => {
2016-10-24 12:28:58 +00:00
println!("{}TupleStruct", ind);
2017-08-09 07:30:56 +00:00
println!(
"{}path: {}",
ind,
print::to_string(print::NO_ANN, |s| s.print_qpath(path, false))
);
2016-10-24 12:28:58 +00:00
if let Some(dot_position) = opt_dots_position {
println!("{}dot position: {}", ind, dot_position);
}
2016-10-24 13:16:21 +00:00
for field in fields {
print_pat(cx, field, indent + 1);
2016-10-24 12:28:58 +00:00
}
},
hir::PatKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
println!("{}Resolved Path, {:?}", ind, ty);
2016-10-24 12:28:58 +00:00
println!("{}path: {:?}", ind, path);
},
hir::PatKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
println!("{}Relative Path, {:?}", ind, ty);
println!("{}seg: {:?}", ind, seg);
},
2019-12-27 07:12:26 +00:00
hir::PatKind::Tuple(pats, opt_dots_position) => {
2016-10-24 12:28:58 +00:00
println!("{}Tuple", ind);
if let Some(dot_position) = opt_dots_position {
println!("{}dot position: {}", ind, dot_position);
}
for field in pats {
2016-10-24 13:16:21 +00:00
print_pat(cx, field, indent + 1);
2016-10-24 12:28:58 +00:00
}
},
hir::PatKind::Box(ref inner) => {
println!("{}Box", ind);
print_pat(cx, inner, indent + 1);
},
hir::PatKind::Ref(ref inner, ref muta) => {
println!("{}Ref", ind);
println!("{}mutability: {:?}", ind, muta);
print_pat(cx, inner, indent + 1);
},
hir::PatKind::Lit(ref e) => {
println!("{}Lit", ind);
print_expr(cx, e, indent + 1);
},
hir::PatKind::Range(ref l, ref r, ref range_end) => {
2016-10-24 12:28:58 +00:00
println!("{}Range", ind);
2020-01-11 00:05:51 +00:00
if let Some(expr) = l {
print_expr(cx, expr, indent + 1);
}
if let Some(expr) = r {
print_expr(cx, expr, indent + 1);
}
match *range_end {
hir::RangeEnd::Included => println!("{} end included", ind),
hir::RangeEnd::Excluded => println!("{} end excluded", ind),
}
2016-10-24 12:28:58 +00:00
},
2019-12-27 07:12:26 +00:00
hir::PatKind::Slice(first_pats, ref range, last_pats) => {
2016-10-24 12:28:58 +00:00
println!("{}Slice [a, b, ..i, y, z]", ind);
println!("[a, b]:");
2016-10-24 13:16:21 +00:00
for pat in first_pats {
2016-10-24 12:28:58 +00:00
print_pat(cx, pat, indent + 1);
}
println!("i:");
if let Some(ref pat) = *range {
print_pat(cx, pat, indent + 1);
}
println!("[y, z]:");
2016-10-24 13:16:21 +00:00
for pat in last_pats {
2016-10-24 12:28:58 +00:00
print_pat(cx, pat, indent + 1);
}
},
}
}
2018-09-02 07:38:25 +00:00
2019-12-27 07:12:26 +00:00
fn print_guard(cx: &LateContext<'_, '_>, guard: &hir::Guard<'_>, indent: usize) {
2018-09-02 07:38:25 +00:00
let ind = " ".repeat(indent);
println!("{}+", ind);
match guard {
hir::Guard::If(expr) => {
println!("{}If", ind);
print_expr(cx, expr, indent + 1);
2018-11-27 20:14:15 +00:00
},
2018-09-02 07:38:25 +00:00
}
}