X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Feval_order_dependence.rs;h=7967d99d104aac2f98269e435f3406d082b13ef9;hb=6d1225981177587fbb68d9c4902c770c3dbaafb0;hp=2db3a2bc00b7c6efeeeddb06ed7af813d56efbdb;hpb=ad638a3e423e5bc2bc621a60eb392ed77209dfe1;p=rust.git

diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 2db3a2bc00b..7967d99d104 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -1,10 +1,11 @@
 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
@@ -42,7 +43,9 @@
     /// shorthand.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```rust,no_run
+    /// # fn b() -> bool { true }
+    /// # fn c() -> bool { true }
     /// let a = b() || panic!() || c();
     /// // `c()` is dead, `panic!()` is only called if `b()` returns `false`
     /// let x = (a, b, c, panic!());
@@ -58,9 +61,9 @@
 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) {
@@ -80,7 +83,7 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
         }
     }
     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);
@@ -98,8 +101,8 @@ struct DivergenceVisitor<'a, 'tcx> {
 
 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 {
@@ -122,14 +125,14 @@ fn report_diverging_sub_expr(&mut self, e: &Expr) {
 
 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);
                         }
                     },
@@ -216,7 +219,7 @@ fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> St
         return StopEarly::KeepGoing;
     }
 
-    match expr.node {
+    match expr.kind {
         ExprKind::Array(_)
         | ExprKind::Tup(_)
         | ExprKind::MethodCall(..)
@@ -259,7 +262,7 @@ fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> St
 }
 
 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.
@@ -290,7 +293,7 @@ fn visit_expr(&mut self, expr: &'tcx Expr) {
             return;
         }
 
-        match expr.node {
+        match expr.kind {
             ExprKind::Path(ref qpath) => {
                 if_chain! {
                     if let QPath::Resolved(None, ref path) = *qpath;
@@ -326,7 +329,7 @@ fn visit_expr(&mut self, expr: &'tcx Expr) {
             // ```
             //
             // TODO: fix this
-            ExprKind::AddrOf(_, _) => {
+            ExprKind::AddrOf(_, _, _) => {
                 return;
             }
             _ => {}
@@ -342,7 +345,7 @@ fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
 /// 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;
         }
     }