use crate::utils::{get_parent_expr, span_lint, span_note_and_lint};
use if_chain::if_chain;
+use rustc::declare_lint_pass;
use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
use rustc::hir::*;
use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
use rustc::ty;
-use rustc::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_tool_lint;
declare_clippy_lint! {
/// **What it does:** Checks for a read and a write to the same variable where
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EvalOrderDependence {
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
// Find a write to a local variable.
- match expr.node {
+ match expr.kind {
ExprKind::Assign(ref lhs, _) | ExprKind::AssignOp(_, ref lhs, _) => {
- if let ExprKind::Path(ref qpath) = lhs.node {
+ if let ExprKind::Path(ref qpath) = lhs.kind {
if let QPath::Resolved(_, ref path) = *qpath {
if path.segments.len() == 1 {
if let def::Res::Local(var) = cx.tables.qpath_res(qpath, lhs.hir_id) {
}
}
fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) {
- match stmt.node {
+ match stmt.kind {
StmtKind::Local(ref local) => {
if let Local { init: Some(ref e), .. } = **local {
DivergenceVisitor { cx }.visit_expr(e);
impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
fn maybe_walk_expr(&mut self, e: &'tcx Expr) {
- match e.node {
- ExprKind::Closure(.., _) => {},
+ match e.kind {
+ ExprKind::Closure(..) => {},
ExprKind::Match(ref e, ref arms, _) => {
self.visit_expr(e);
for arm in arms {
impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
fn visit_expr(&mut self, e: &'tcx Expr) {
- match e.node {
+ match e.kind {
ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => self.report_diverging_sub_expr(e),
ExprKind::Call(ref func, _) => {
let typ = self.cx.tables.expr_ty(func);
- match typ.sty {
+ match typ.kind {
ty::FnDef(..) | ty::FnPtr(_) => {
let sig = typ.fn_sig(self.cx.tcx);
- if let ty::Never = self.cx.tcx.erase_late_bound_regions(&sig).output().sty {
+ if let ty::Never = self.cx.tcx.erase_late_bound_regions(&sig).output().kind {
self.report_diverging_sub_expr(e);
}
},
return StopEarly::KeepGoing;
}
- match expr.node {
+ match expr.kind {
ExprKind::Array(_)
| ExprKind::Tup(_)
| ExprKind::MethodCall(..)
}
fn check_stmt<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt) -> StopEarly {
- match stmt.node {
+ match stmt.kind {
StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => check_expr(vis, expr),
// If the declaration is of a local variable, check its initializer
// expression if it has one. Otherwise, keep going.
return;
}
- match expr.node {
+ match expr.kind {
ExprKind::Path(ref qpath) => {
if_chain! {
if let QPath::Resolved(None, ref path) = *qpath;
// ```
//
// TODO: fix this
- ExprKind::AddrOf(_, _) => {
+ ExprKind::AddrOf(_, _, _) => {
return;
}
_ => {}
/// Returns `true` if `expr` is the LHS of an assignment, like `expr = ...`.
fn is_in_assignment_position(cx: &LateContext<'_, '_>, expr: &Expr) -> bool {
if let Some(parent) = get_parent_expr(cx, expr) {
- if let ExprKind::Assign(ref lhs, _) = parent.node {
+ if let ExprKind::Assign(ref lhs, _) = parent.kind {
return lhs.hir_id == expr.hir_id;
}
}