Rustup

Author: oli-obk

Cargo.lock

@@ -7,7 +7,7 @@ use rustc::ty::{self, TyCtxt};
 use semver::Version;
 use syntax::ast::{Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem, NestedMetaItemKind};
 use syntax::codemap::Span;
-use utils::{in_macro, match_def_path, paths, snippet_opt, span_lint, span_lint_and_then};
+use utils::{in_macro, match_def_path, paths, snippet_opt, span_lint, span_lint_and_then, opt_def_id};
 
 /// **What it does:** Checks for items annotated with `#[inline(always)]`,
 /// unless the annotated function is empty or simply panics.
@@ -211,8 +211,11 @@ fn is_relevant_expr(tcx: TyCtxt, tables: &ty::TypeckTables, expr: &Expr) -> bool
         ExprRet(Some(ref e)) => is_relevant_expr(tcx, tables, e),
         ExprRet(None) | ExprBreak(_, None) => false,
         ExprCall(ref path_expr, _) => if let ExprPath(ref qpath) = path_expr.node {
-            let fun_id = tables.qpath_def(qpath, path_expr.hir_id).def_id();
-            !match_def_path(tcx, fun_id, &paths::BEGIN_PANIC)
+            if let Some(fun_id) = opt_def_id(tables.qpath_def(qpath, path_expr.hir_id)) {
+                !match_def_path(tcx, fun_id, &paths::BEGIN_PANIC)
+            } else {
+                true
+            }
         } else {
             true
         },

clippy_lints/src/attrs.rs

@@ -1,7 +1,7 @@
 use rustc::lint::*;
 use rustc::ty;
 use rustc::hir::*;
-use utils::{is_copy, match_def_path, paths, span_note_and_lint};
+use utils::{is_copy, match_def_path, paths, span_note_and_lint, opt_def_id};
 
 /// **What it does:** Checks for calls to `std::mem::drop` with a reference
 /// instead of an owned value.
@@ -119,8 +119,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
             let ExprCall(ref path, ref args) = expr.node,
             let ExprPath(ref qpath) = path.node,
             args.len() == 1,
+            let Some(def_id) = opt_def_id(cx.tables.qpath_def(qpath, path.hir_id)),
         ], {
-            let def_id = cx.tables.qpath_def(qpath, path.hir_id).def_id();
             let lint;
             let msg;
             let arg = &args[0];

clippy_lints/src/drop_forget_ref.rs

@@ -1,8 +1,8 @@
-use rustc::hir::def_id::DefId;
 use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc::hir::*;
 use rustc::ty;
 use rustc::lint::*;
+use syntax::ast;
 use utils::{get_parent_expr, span_lint, span_note_and_lint};
 
 /// **What it does:** Checks for a read and a write to the same variable where
@@ -65,14 +65,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EvalOrderDependence {
             ExprAssign(ref lhs, _) | ExprAssignOp(_, ref lhs, _) => if let ExprPath(ref qpath) = lhs.node {
                 if let QPath::Resolved(_, ref path) = *qpath {
                     if path.segments.len() == 1 {
-                        let var = cx.tables.qpath_def(qpath, lhs.hir_id).def_id();
-                        let mut visitor = ReadVisitor {
-                            cx: cx,
-                            var: var,
-                            write_expr: expr,
-                            last_expr: expr,
-                        };
-                        check_for_unsequenced_reads(&mut visitor);
+                        if let def::Def::Local(var) = cx.tables.qpath_def(qpath, lhs.hir_id) {
+                            let mut visitor = ReadVisitor {
+                                cx: cx,
+                                var: var,
+                                write_expr: expr,
+                                last_expr: expr,
+                            };
+                            check_for_unsequenced_reads(&mut visitor);
+                        }
                     }
                 }
             },
@@ -280,7 +281,7 @@ fn check_stmt<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt) -> St
 struct ReadVisitor<'a, 'tcx: 'a> {
     cx: &'a LateContext<'a, 'tcx>,
     /// The id of the variable we're looking for.
-    var: DefId,
+    var: ast::NodeId,
     /// The expressions where the write to the variable occurred (for reporting
     /// in the lint).
     write_expr: &'tcx Expr,
@@ -297,22 +298,23 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> {
 
         match expr.node {
             ExprPath(ref qpath) => {
-                if let QPath::Resolved(None, ref path) = *qpath {
-                    if path.segments.len() == 1 && self.cx.tables.qpath_def(qpath, expr.hir_id).def_id() == self.var {
-                        if is_in_assignment_position(self.cx, expr) {
-                            // This is a write, not a read.
-                        } else {
-                            span_note_and_lint(
-                                self.cx,
-                                EVAL_ORDER_DEPENDENCE,
-                                expr.span,
-                                "unsequenced read of a variable",
-                                self.write_expr.span,
-                                "whether read occurs before this write depends on evaluation order"
-                            );
-                        }
-                    }
-                }
+                if_let_chain! {[
+                    let QPath::Resolved(None, ref path) = *qpath,
+                    path.segments.len() == 1,
+                    let def::Def::Local(local_id) = self.cx.tables.qpath_def(qpath, expr.hir_id),
+                    local_id == self.var,
+                    // Check that this is a read, not a write.
+                    !is_in_assignment_position(self.cx, expr),
+                ], {
+                    span_note_and_lint(
+                        self.cx,
+                        EVAL_ORDER_DEPENDENCE,
+                        expr.span,
+                        "unsequenced read of a variable",
+                        self.write_expr.span,
+                        "whether read occurs before this write depends on evaluation order"
+                    );
+                }}
             }
             // We're about to descend a closure. Since we don't know when (or
             // if) the closure will be evaluated, any reads in it might not

clippy_lints/src/eval_order_dependence.rs

@@ -5,7 +5,7 @@ use rustc::ty;
 use syntax::ast::LitKind;
 use syntax::symbol::InternedString;
 use utils::paths;
-use utils::{is_expn_of, match_def_path, match_type, resolve_node, span_lint, walk_ptrs_ty};
+use utils::{is_expn_of, match_def_path, match_type, resolve_node, span_lint, walk_ptrs_ty, opt_def_id};
 
 /// **What it does:** Checks for the use of `format!("string literal with no
 /// argument")` and `format!("{}", foo)` where `foo` is a string.
@@ -47,7 +47,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                     if_let_chain!{[
                         let ExprPath(ref qpath) = fun.node,
                         args.len() == 2,
-                        match_def_path(cx.tcx, resolve_node(cx, qpath, fun.hir_id).def_id(), &paths::FMT_ARGUMENTS_NEWV1),
+                        let Some(fun_def_id) = opt_def_id(resolve_node(cx, qpath, fun.hir_id)),
+                        match_def_path(cx.tcx, fun_def_id, &paths::FMT_ARGUMENTS_NEWV1),
                         // ensure the format string is `"{..}"` with only one argument and no text
                         check_static_str(cx, &args[0]),
                         // ensure the format argument is `{}` ie. Display with no fancy option
@@ -128,7 +129,8 @@ fn check_arg_is_display(cx: &LateContext, expr: &Expr) -> bool {
         let ExprCall(_, ref args) = exprs[0].node,
         args.len() == 2,
         let ExprPath(ref qpath) = args[1].node,
-        match_def_path(cx.tcx, resolve_node(cx, qpath, args[1].hir_id).def_id(), &paths::DISPLAY_FMT_METHOD),
+        let Some(fun_def_id) = opt_def_id(resolve_node(cx, qpath, args[1].hir_id)),
+        match_def_path(cx.tcx, fun_def_id, &paths::DISPLAY_FMT_METHOD),
     ], {
         let ty = walk_ptrs_ty(cx.tables.pat_ty(&pat[0]));
 

clippy_lints/src/format.rs

@@ -2,6 +2,7 @@ use rustc::hir::intravisit;
 use rustc::hir;
 use rustc::lint::*;
 use rustc::ty;
+use rustc::hir::def::Def;
 use std::collections::HashSet;
 use syntax::ast;
 use syntax::abi::Abi;
@@ -166,17 +167,17 @@ impl<'a, 'tcx> Functions {
     }
 }
 
-fn raw_ptr_arg(arg: &hir::Arg, ty: &hir::Ty) -> Option<hir::def_id::DefId> {
-    if let (&hir::PatKind::Binding(_, def_id, _, _), &hir::TyPtr(_)) = (&arg.pat.node, &ty.node) {
-        Some(def_id)
+fn raw_ptr_arg(arg: &hir::Arg, ty: &hir::Ty) -> Option<ast::NodeId> {
+    if let (&hir::PatKind::Binding(_, id, _, _), &hir::TyPtr(_)) = (&arg.pat.node, &ty.node) {
+        Some(id)
     } else {
         None
     }
 }
 
 struct DerefVisitor<'a, 'tcx: 'a> {
     cx: &'a LateContext<'a, 'tcx>,
-    ptrs: HashSet<hir::def_id::DefId>,
+    ptrs: HashSet<ast::NodeId>,
     tables: &'a ty::TypeckTables<'tcx>,
 }
 
@@ -216,14 +217,15 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
 impl<'a, 'tcx: 'a> DerefVisitor<'a, 'tcx> {
     fn check_arg(&self, ptr: &hir::Expr) {
         if let hir::ExprPath(ref qpath) = ptr.node {
-            let def = self.cx.tables.qpath_def(qpath, ptr.hir_id);
-            if self.ptrs.contains(&def.def_id()) {
-                span_lint(
-                    self.cx,
-                    NOT_UNSAFE_PTR_ARG_DEREF,
-                    ptr.span,
-                    "this public function dereferences a raw pointer but is not marked `unsafe`",
-                );
+            if let Def::Local(id) = self.cx.tables.qpath_def(qpath, ptr.hir_id) {
+                if self.ptrs.contains(&id) {
+                    span_lint(
+                        self.cx,
+                        NOT_UNSAFE_PTR_ARG_DEREF,
+                        ptr.span,
+                        "this public function dereferences a raw pointer but is not marked `unsafe`",
+                    );
+                }
             }
         }
     }

clippy_lints/src/functions.rs

@@ -1,6 +1,8 @@
 use rustc::lint::*;
 use rustc::hir;
 use rustc::hir::BindingAnnotation;
+use rustc::hir::def::Def;
+use syntax::ast;
 use utils::{snippet, span_lint_and_then};
 
 /// **What it does:** Checks for variable declarations immediately followed by a
@@ -65,19 +67,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetIfSeq {
                 let Some(expr) = it.peek(),
                 let hir::StmtDecl(ref decl, _) = stmt.node,
                 let hir::DeclLocal(ref decl) = decl.node,
-                let hir::PatKind::Binding(mode, def_id, ref name, None) = decl.pat.node,
+                let hir::PatKind::Binding(mode, canonical_id, ref name, None) = decl.pat.node,
                 let hir::StmtExpr(ref if_, _) = expr.node,
                 let hir::ExprIf(ref cond, ref then, ref else_) = if_.node,
-                !used_in_expr(cx, def_id, cond),
+                !used_in_expr(cx, canonical_id, cond),
                 let hir::ExprBlock(ref then) = then.node,
-                let Some(value) = check_assign(cx, def_id, &*then),
-                !used_in_expr(cx, def_id, value),
+                let Some(value) = check_assign(cx, canonical_id, &*then),
+                !used_in_expr(cx, canonical_id, value),
             ], {
                 let span = stmt.span.to(if_.span);
 
                 let (default_multi_stmts, default) = if let Some(ref else_) = *else_ {
                     if let hir::ExprBlock(ref else_) = else_.node {
-                        if let Some(default) = check_assign(cx, def_id, else_) {
+                        if let Some(default) = check_assign(cx, canonical_id, else_) {
                             (else_.stmts.len() > 1, default)
                         } else if let Some(ref default) = decl.init {
                             (true, &**default)
@@ -130,15 +132,16 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetIfSeq {
 
 struct UsedVisitor<'a, 'tcx: 'a> {
     cx: &'a LateContext<'a, 'tcx>,
-    id: hir::def_id::DefId,
+    id: ast::NodeId,
     used: bool,
 }
 
 impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for UsedVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
         if_let_chain! {[
             let hir::ExprPath(ref qpath) = expr.node,
-            self.id == self.cx.tables.qpath_def(qpath, expr.hir_id).def_id(),
+            let Def::Local(local_id) = self.cx.tables.qpath_def(qpath, expr.hir_id),
+            self.id == local_id,
         ], {
             self.used = true;
             return;
@@ -152,7 +155,7 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for UsedVisitor<'a, 'tcx> {
 
 fn check_assign<'a, 'tcx>(
     cx: &LateContext<'a, 'tcx>,
-    decl: hir::def_id::DefId,
+    decl: ast::NodeId,
     block: &'tcx hir::Block,
 ) -> Option<&'tcx hir::Expr> {
     if_let_chain! {[
@@ -161,7 +164,8 @@ fn check_assign<'a, 'tcx>(
         let hir::StmtSemi(ref expr, _) = expr.node,
         let hir::ExprAssign(ref var, ref value) = expr.node,
         let hir::ExprPath(ref qpath) = var.node,
-        decl == cx.tables.qpath_def(qpath, var.hir_id).def_id(),
+        let Def::Local(local_id) = cx.tables.qpath_def(qpath, var.hir_id),
+        decl == local_id,
     ], {
         let mut v = UsedVisitor {
             cx: cx,
@@ -183,7 +187,7 @@ fn check_assign<'a, 'tcx>(
     None
 }
 
-fn used_in_expr<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, id: hir::def_id::DefId, expr: &'tcx hir::Expr) -> bool {
+fn used_in_expr<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, id: ast::NodeId, expr: &'tcx hir::Expr) -> bool {
     let mut v = UsedVisitor {
         cx: cx,
         id: id,