use if_chain::if_chain;
use rustc_ast::ast::{self, LitKind};
use rustc_hir as hir;
-use rustc_hir::{Block, BorrowKind, Expr, ExprKind, LoopSource, Node, Pat, StmtKind, UnOp};
+use rustc_hir::{Arm, Block, BorrowKind, Expr, ExprKind, LoopSource, MatchSource, Node, Pat, StmtKind, UnOp};
use rustc_lint::LateContext;
use rustc_span::{sym, ExpnKind, Span, Symbol};
/// The essential nodes of a desugared for loop as well as the entire span:
/// `for pat in arg { body }` becomes `(pat, arg, body)`. Return `(pat, arg, body, span)`.
pub struct ForLoop<'tcx> {
+ /// `for` loop item
pub pat: &'tcx hir::Pat<'tcx>,
+ /// `IntoIterator` argument
pub arg: &'tcx hir::Expr<'tcx>,
+ /// `for` loop body
pub body: &'tcx hir::Expr<'tcx>,
+ /// entire `for` loop span
pub span: Span,
}
impl<'tcx> ForLoop<'tcx> {
#[inline]
+ /// Parses a desugared `for` loop
pub fn hir(expr: &Expr<'tcx>) -> Option<Self> {
if_chain! {
- if let hir::ExprKind::Match(ref iterexpr, ref arms, hir::MatchSource::ForLoopDesugar) = expr.kind;
+ if let hir::ExprKind::Match(iterexpr, arms, hir::MatchSource::ForLoopDesugar) = expr.kind;
if let Some(first_arm) = arms.get(0);
- if let hir::ExprKind::Call(_, ref iterargs) = iterexpr.kind;
+ if let hir::ExprKind::Call(_, iterargs) = iterexpr.kind;
if let Some(first_arg) = iterargs.get(0);
if iterargs.len() == 1 && arms.len() == 1 && first_arm.guard.is_none();
- if let hir::ExprKind::Loop(ref block, ..) = first_arm.body.kind;
+ if let hir::ExprKind::Loop(block, ..) = first_arm.body.kind;
if block.expr.is_none();
if let [ _, _, ref let_stmt, ref body ] = *block.stmts;
- if let hir::StmtKind::Local(ref local) = let_stmt.kind;
- if let hir::StmtKind::Expr(ref body_expr) = body.kind;
+ if let hir::StmtKind::Local(local) = let_stmt.kind;
+ if let hir::StmtKind::Expr(body_expr) = body.kind;
then {
return Some(Self {
pat: &*local.pat,
}
}
+/// An `if` expression without `DropTemps`
pub struct If<'hir> {
+ /// `if` condition
pub cond: &'hir Expr<'hir>,
- pub r#else: Option<&'hir Expr<'hir>>,
+ /// `if` then expression
pub then: &'hir Expr<'hir>,
+ /// `else` expression
+ pub r#else: Option<&'hir Expr<'hir>>,
}
impl<'hir> If<'hir> {
#[inline]
+ /// Parses an `if` expression
pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
if let ExprKind::If(
Expr {
r#else,
) = expr.kind
{
- Some(Self { cond, r#else, then })
+ Some(Self { cond, then, r#else })
} else {
None
}
}
}
+/// An `if let` expression
pub struct IfLet<'hir> {
+ /// `if let` pattern
pub let_pat: &'hir Pat<'hir>,
+ /// `if let` scrutinee
pub let_expr: &'hir Expr<'hir>,
+ /// `if let` then expression
pub if_then: &'hir Expr<'hir>,
+ /// `if let` else expression
pub if_else: Option<&'hir Expr<'hir>>,
}
impl<'hir> IfLet<'hir> {
- #[inline]
- pub fn ast(cx: &LateContext<'tcx>, expr: &Expr<'hir>) -> Option<Self> {
- let rslt = Self::hir(expr)?;
- Self::is_not_within_while_context(cx, expr)?;
- Some(rslt)
- }
-
- #[inline]
- pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
+ /// Parses an `if let` expression
+ pub fn hir(cx: &LateContext<'_>, expr: &Expr<'hir>) -> Option<Self> {
if let ExprKind::If(
Expr {
kind: ExprKind::Let(let_pat, let_expr, _),
if_else,
) = expr.kind
{
+ let hir = cx.tcx.hir();
+ let mut iter = hir.parent_iter(expr.hir_id);
+ if let Some((_, Node::Block(Block { stmts: [], .. }))) = iter.next() {
+ if let Some((
+ _,
+ Node::Expr(Expr {
+ kind: ExprKind::Loop(_, _, LoopSource::While, _),
+ ..
+ }),
+ )) = iter.next()
+ {
+ // while loop desugar
+ return None;
+ }
+ }
return Some(Self {
let_pat,
let_expr,
}
None
}
+}
- #[inline]
- fn is_not_within_while_context(cx: &LateContext<'tcx>, expr: &Expr<'hir>) -> Option<()> {
- let hir = cx.tcx.hir();
- let parent = hir.get_parent_node(expr.hir_id);
- let parent_parent = hir.get_parent_node(parent);
- let parent_parent_node = hir.get(parent_parent);
- if let Node::Expr(Expr {
- kind: ExprKind::Loop(_, _, LoopSource::While, _),
- ..
- }) = parent_parent_node
- {
- return None;
+/// An `if let` or `match` expression. Useful for lints that trigger on one or the other.
+pub enum IfLetOrMatch<'hir> {
+ /// Any `match` expression
+ Match(&'hir Expr<'hir>, &'hir [Arm<'hir>], MatchSource),
+ /// scrutinee, pattern, then block, else block
+ IfLet(
+ &'hir Expr<'hir>,
+ &'hir Pat<'hir>,
+ &'hir Expr<'hir>,
+ Option<&'hir Expr<'hir>>,
+ ),
+}
+
+impl<'hir> IfLetOrMatch<'hir> {
+ /// Parses an `if let` or `match` expression
+ pub fn parse(cx: &LateContext<'_>, expr: &Expr<'hir>) -> Option<Self> {
+ match expr.kind {
+ ExprKind::Match(expr, arms, source) => Some(Self::Match(expr, arms, source)),
+ _ => IfLet::hir(cx, expr).map(
+ |IfLet {
+ let_expr,
+ let_pat,
+ if_then,
+ if_else,
+ }| { Self::IfLet(let_expr, let_pat, if_then, if_else) },
+ ),
}
- Some(())
}
}
+/// An `if` or `if let` expression
pub struct IfOrIfLet<'hir> {
+ /// `if` condition that is maybe a `let` expression
pub cond: &'hir Expr<'hir>,
- pub r#else: Option<&'hir Expr<'hir>>,
+ /// `if` then expression
pub then: &'hir Expr<'hir>,
+ /// `else` expression
+ pub r#else: Option<&'hir Expr<'hir>>,
}
impl<'hir> IfOrIfLet<'hir> {
#[inline]
+ /// Parses an `if` or `if let` expression
pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
if let ExprKind::If(cond, then, r#else) = expr.kind {
if let ExprKind::DropTemps(new_cond) = cond.kind {
});
}
if let ExprKind::Let(..) = cond.kind {
- return Some(Self { cond, r#else, then });
+ return Some(Self { cond, then, r#else });
}
}
None
}
match expr.kind {
- hir::ExprKind::Call(ref path, ref args)
+ hir::ExprKind::Call(path, args)
if matches!(
path.kind,
hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, _))
limits: ast::RangeLimits::Closed,
})
},
- hir::ExprKind::Struct(ref path, ref fields, None) => match path {
+ hir::ExprKind::Struct(path, fields, None) => match &path {
hir::QPath::LangItem(hir::LangItem::RangeFull, _) => Some(Range {
start: None,
end: None,
/// from `vec!`.
pub fn hir(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) -> Option<VecArgs<'a>> {
if_chain! {
- if let hir::ExprKind::Call(ref fun, ref args) = expr.kind;
+ if let hir::ExprKind::Call(fun, args) = expr.kind;
if let hir::ExprKind::Path(ref qpath) = fun.kind;
if is_expn_of(fun.span, "vec").is_some();
if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
else if match_def_path(cx, fun_def_id, &paths::SLICE_INTO_VEC) && args.len() == 1 {
// `vec![a, b, c]` case
if_chain! {
- if let hir::ExprKind::Box(ref boxed) = args[0].kind;
- if let hir::ExprKind::Array(ref args) = boxed.kind;
+ if let hir::ExprKind::Box(boxed) = args[0].kind;
+ if let hir::ExprKind::Array(args) = boxed.kind;
then {
- return Some(VecArgs::Vec(&*args));
+ return Some(VecArgs::Vec(args));
}
}
}
}
+/// A desugared `while` loop
pub struct While<'hir> {
- pub if_cond: &'hir Expr<'hir>,
- pub if_then: &'hir Expr<'hir>,
- pub if_else: Option<&'hir Expr<'hir>>,
+ /// `while` loop condition
+ pub condition: &'hir Expr<'hir>,
+ /// `while` loop body
+ pub body: &'hir Expr<'hir>,
}
impl<'hir> While<'hir> {
#[inline]
+ /// Parses a desugared `while` loop
pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
if let ExprKind::Loop(
Block {
kind:
ExprKind::If(
Expr {
- kind: ExprKind::DropTemps(if_cond),
+ kind: ExprKind::DropTemps(condition),
..
},
- if_then,
- if_else_ref,
+ body,
+ _,
),
..
}),
_,
) = expr.kind
{
- let if_else = *if_else_ref;
- return Some(Self {
- if_cond,
- if_then,
- if_else,
- });
+ return Some(Self { condition, body });
}
None
}
}
+/// A desugared `while let` loop
pub struct WhileLet<'hir> {
- pub if_expr: &'hir Expr<'hir>,
+ /// `while let` loop item pattern
pub let_pat: &'hir Pat<'hir>,
+ /// `while let` loop scrutinee
pub let_expr: &'hir Expr<'hir>,
+ /// `while let` loop body
pub if_then: &'hir Expr<'hir>,
- pub if_else: Option<&'hir Expr<'hir>>,
}
impl<'hir> WhileLet<'hir> {
#[inline]
+ /// Parses a desugared `while let` loop
pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
if let ExprKind::Loop(
Block {
- expr: Some(if_expr), ..
+ expr:
+ Some(Expr {
+ kind:
+ ExprKind::If(
+ Expr {
+ kind: ExprKind::Let(let_pat, let_expr, _),
+ ..
+ },
+ if_then,
+ _,
+ ),
+ ..
+ }),
+ ..
},
_,
LoopSource::While,
_,
) = expr.kind
{
- if let Expr {
- kind:
- ExprKind::If(
- Expr {
- kind: ExprKind::Let(let_pat, let_expr, _),
- ..
- },
- if_then,
- if_else_ref,
- ),
- ..
- } = if_expr
- {
- let if_else = *if_else_ref;
- return Some(Self {
- if_expr,
- let_pat,
- let_expr,
- if_then,
- if_else,
- });
- }
+ return Some(Self {
+ let_pat,
+ let_expr,
+ if_then,
+ });
}
None
}
if let ExpnKind::Macro(_, name) = expr.span.ctxt().outer_expn_data().kind;
let name = name.as_str();
if name.ends_with("format_args") || name.ends_with("format_args_nl");
- if let ExprKind::Call(_, args) = expr.kind;
- if let Some((strs_ref, args, fmt_expr)) = match args {
+
+ if let ExprKind::Match(inner_match, [arm], _) = expr.kind;
+
+ // `match match`, if you will
+ if let ExprKind::Match(args, [inner_arm], _) = inner_match.kind;
+ if let ExprKind::Tup(value_args) = args.kind;
+ if let Some(value_args) = value_args
+ .iter()
+ .map(|e| match e.kind {
+ ExprKind::AddrOf(_, _, e) => Some(e),
+ _ => None,
+ })
+ .collect();
+ if let ExprKind::Array(args) = inner_arm.body.kind;
+
+ if let ExprKind::Block(Block { stmts: [], expr: Some(expr), .. }, _) = arm.body.kind;
+ if let ExprKind::Call(_, call_args) = expr.kind;
+ if let Some((strs_ref, fmt_expr)) = match call_args {
// Arguments::new_v1
- [strs_ref, args] => Some((strs_ref, args, None)),
+ [strs_ref, _] => Some((strs_ref, None)),
// Arguments::new_v1_formatted
- [strs_ref, args, fmt_expr] => Some((strs_ref, args, Some(fmt_expr))),
+ [strs_ref, _, fmt_expr] => Some((strs_ref, Some(fmt_expr))),
_ => None,
};
if let ExprKind::AddrOf(BorrowKind::Ref, _, strs_arr) = strs_ref.kind;
None
})
.collect();
- if let ExprKind::AddrOf(BorrowKind::Ref, _, args) = args.kind;
- if let ExprKind::Match(args, [arm], _) = args.kind;
- if let ExprKind::Tup(value_args) = args.kind;
- if let Some(value_args) = value_args
- .iter()
- .map(|e| match e.kind {
- ExprKind::AddrOf(_, _, e) => Some(e),
- _ => None,
- })
- .collect();
- if let ExprKind::Array(args) = arm.body.kind;
then {
Some(FormatArgsExpn {
format_string_span: strs_ref.span,
// }
// ```
if_chain! {
- if let Some(ref expr) = local.init;
+ if let Some(expr) = local.init;
if let hir::ExprKind::Match(_, _, hir::MatchSource::ForLoopDesugar) = expr.kind;
then {
return true;
projects / rust.git / blobdiff