Change:
} } } <ins> declare_lint! { /// The `deref_nullptr` lint detects when an null pointer is dereferenced, /// which causes [undefined behavior]. /// /// ### Example /// /// ```rust,no_run /// # #![allow(unused)] /// use std::ptr; /// unsafe { ///     let x = &*ptr::null::<i32>(); ///     let x = ptr::addr_of!(*ptr::null::<i32>()); ///     let x = *(0 as *const i32); /// } /// ``` /// /// {{produces}} /// /// ### Explanation /// /// Dereferencing a null pointer causes [undefined behavior] even as a place expression, /// like `&*(0 as *const i32)` or `addr_of!(*(0 as *const i32))`. /// /// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html pub DEREF_NULLPTR, Warn, "detects when an null pointer is dereferenced" } declare_lint_pass!(DerefNullPtr => [DEREF_NULLPTR]); impl<'tcx> LateLintPass<'tcx> for DerefNullPtr { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) { /// test if expression is a null ptr fn is_null_ptr(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool { match &expr.kind { rustc_hir::ExprKind::Cast(ref expr, ref ty) => { if let rustc_hir::TyKind::Ptr(_) = ty.kind { return is_zero(expr) || is_null_ptr(cx, expr); } } // check for call to `core::ptr::null` or `core::ptr::null_mut` rustc_hir::ExprKind::Call(ref path, _) => { if let rustc_hir::ExprKind::Path(ref qpath) = path.kind { if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id() { return cx.tcx.is_diagnostic_item(sym::ptr_null, def_id) || cx.tcx.is_diagnostic_item(sym::ptr_null_mut, def_id); } } } _ => {} } false } /// test if experssion is the literal `0` fn is_zero(expr: &hir::Expr<'_>) -> bool { match &expr.kind { rustc_hir::ExprKind::Lit(ref lit) => { if let LitKind::Int(a, _) = lit.node { return a == 0; } } _ => {} } false } if let rustc_hir::ExprKind::Unary(ref un_op, ref expr_deref) = expr.kind { if let rustc_hir::UnOp::Deref = un_op { if is_null_ptr(cx, expr_deref) { cx.struct_span_lint(DEREF_NULLPTR, expr.span, |lint| { let mut err = lint.build("dereferencing a null pointer"); err.span_label( expr.span, "this code causes undefined behavior when executed", ); err.emit(); }); } } } } } </ins>

Discussion:
I propose we add a lint that detects code like Some people seem to think that this is okay in contexts like or , but that is not the case -- on a NULL pointer is UB even as a place expression. To implement this, you can use the lint as a template: should check for  expressions with a operator, and then check the operand to be either a cast of to a pointer type, or a call to one of the methods. To detect the methods, make them "diagnostic items"; the lint does that e.g. for so it can again serve as a template here. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --
Ah, turns out clippy already has a lint for this: . So maybe we should just move that to rustc? Cc
claim
awesome. :) Let me know if you need any help.
Thanks :)
Did you mean something slightly different with your "okay in contexts like" examples, perhaps? Neither of those two actually compile as written, since they're just attempts to deference something that isn't even a pointer. You get: in both cases.
oops I screwed up the casts, should be fixed now.
Yeah, happy to have Clippy lints upstreamed to rust, let us know when it's done so we can deprecate it on our end
for detecting a call like you said to use . However I do not know what to use for the symbol argument. There is that defines symbol but nothing looks like creating a null ptr. Should I add one what should it look like ?
You first need to add the diagnostic item attribute to the relevant function inside , like so: This name must be globally unique, e.g. and . Then you add those names to the list in (please keep it alphabetically sorted), and then you can use them for .