rustup https://github.com/rust-lang/rust/pull/68944

[rust.git] / clippy_lints / src / fallible_impl_from.rs

diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 1cbe9d218bdfd27e42322458ed737e51d8eaff7c..5ed7fd49f472110ad4ced1639d635771549dbf33 100644 (file)
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -1,11 +1,12 @@
 use crate::utils::paths::{BEGIN_PANIC, BEGIN_PANIC_FMT, FROM_TRAIT, OPTION, RESULT};
-use crate::utils::{is_expn_of, method_chain_args, span_lint_and_then, walk_ptrs_ty};
+use crate::utils::{is_expn_of, match_def_path, method_chain_args, span_lint_and_then, walk_ptrs_ty};
 use if_chain::if_chain;
-use rustc::hir;
-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use rustc::hir::map::Map;
 use rustc::ty::{self, Ty};
-use rustc::{declare_lint_pass, declare_tool_lint};
-use syntax_pos::Span;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for impls of `From<..>` that contain `panic!()` or `unwrap()`
@@ -31,13 +32,13 @@
 declare_lint_pass!(FallibleImplFrom => [FALLIBLE_IMPL_FROM]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for FallibleImplFrom {
-    fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {
+    fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item<'_>) {
         // check for `impl From<???> for ..`
-        let impl_def_id = cx.tcx.hir().local_def_id_from_hir_id(item.hir_id);
+        let impl_def_id = cx.tcx.hir().local_def_id(item.hir_id);
         if_chain! {
-            if let hir::ItemKind::Impl(.., ref impl_items) = item.node;
+            if let hir::ItemKind::Impl{ items: impl_items, .. } = item.kind;
             if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_def_id);
-            if cx.match_def_path(impl_trait_ref.def_id, &FROM_TRAIT);
+            if match_def_path(cx, impl_trait_ref.def_id, &FROM_TRAIT);
             then {
                 lint_impl_body(cx, item.span, impl_items);
             }
@@ -45,25 +46,27 @@ fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {
     }
 }
 
-fn lint_impl_body<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, impl_span: Span, impl_items: &hir::HirVec<hir::ImplItemRef>) {
-    use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor};
-    use rustc::hir::*;
+fn lint_impl_body<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, impl_span: Span, impl_items: &[hir::ImplItemRef<'_>]) {
+    use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+    use rustc_hir::{Expr, ExprKind, ImplItemKind, QPath};
 
-    struct FindPanicUnwrap<'a, 'tcx: 'a> {
+    struct FindPanicUnwrap<'a, 'tcx> {
         lcx: &'a LateContext<'a, 'tcx>,
         tables: &'tcx ty::TypeckTables<'tcx>,
         result: Vec<Span>,
     }
 
-    impl<'a, 'tcx: 'a> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
-        fn visit_expr(&mut self, expr: &'tcx Expr) {
+    impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
+        type Map = Map<'tcx>;
+
+        fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
             // check for `begin_panic`
             if_chain! {
-                if let ExprKind::Call(ref func_expr, _) = expr.node;
-                if let ExprKind::Path(QPath::Resolved(_, ref path)) = func_expr.node;
-                if let Some(path_def_id) = path.def.opt_def_id();
-                if self.lcx.match_def_path(path_def_id, &BEGIN_PANIC) ||
-                    self.lcx.match_def_path(path_def_id, &BEGIN_PANIC_FMT);
+                if let ExprKind::Call(ref func_expr, _) = expr.kind;
+                if let ExprKind::Path(QPath::Resolved(_, ref path)) = func_expr.kind;
+                if let Some(path_def_id) = path.res.opt_def_id();
+                if match_def_path(self.lcx, path_def_id, &BEGIN_PANIC) ||
+                    match_def_path(self.lcx, path_def_id, &BEGIN_PANIC_FMT);
                 if is_expn_of(expr.span, "unreachable").is_none();
                 then {
                     self.result.push(expr.span);
@@ -82,20 +85,20 @@ fn visit_expr(&mut self, expr: &'tcx Expr) {
             intravisit::walk_expr(self, expr);
         }
 
-        fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
             NestedVisitorMap::None
         }
     }
 
     for impl_item in impl_items {
         if_chain! {
-            if impl_item.ident.name == "from";
+            if impl_item.ident.name == sym!(from);
             if let ImplItemKind::Method(_, body_id) =
-                cx.tcx.hir().impl_item(impl_item.id).node;
+                cx.tcx.hir().impl_item(impl_item.id).kind;
             then {
                 // check the body for `begin_panic` or `unwrap`
                 let body = cx.tcx.hir().body(body_id);
-                let impl_item_def_id = cx.tcx.hir().local_def_id_from_hir_id(impl_item.id.hir_id);
+                let impl_item_def_id = cx.tcx.hir().local_def_id(impl_item.id.hir_id);
                 let mut fpu = FindPanicUnwrap {
                     lcx: cx,
                     tables: cx.tcx.typeck_tables_of(impl_item_def_id),
@@ -123,8 +126,8 @@ fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
 }
 
 fn match_type(cx: &LateContext<'_, '_>, ty: Ty<'_>, path: &[&str]) -> bool {
-    match ty.sty {
-        ty::Adt(adt, _) => cx.match_def_path(adt.did, path),
+    match ty.kind {
+        ty::Adt(adt, _) => match_def_path(cx, adt.did, path),
         _ => false,
     }
 }