1 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
2 use clippy_utils::source::snippet_opt;
3 use rustc_errors::Applicability;
4 use rustc_hir::{Expr, ExprKind};
5 use rustc_lint::{LateContext, LateLintPass};
6 use rustc_session::{declare_lint_pass, declare_tool_lint};
10 declare_clippy_lint! {
12 /// Checks for usage of the `offset` pointer method with a `usize` casted to an
15 /// ### Why is this bad?
16 /// If we’re always increasing the pointer address, we can avoid the numeric
17 /// cast by using the `add` method instead.
21 /// let vec = vec![b'a', b'b', b'c'];
22 /// let ptr = vec.as_ptr();
23 /// let offset = 1_usize;
26 /// ptr.offset(offset as isize);
33 /// let vec = vec![b'a', b'b', b'c'];
34 /// let ptr = vec.as_ptr();
35 /// let offset = 1_usize;
41 #[clippy::version = "1.30.0"]
42 pub PTR_OFFSET_WITH_CAST,
44 "unneeded pointer offset cast"
47 declare_lint_pass!(PtrOffsetWithCast => [PTR_OFFSET_WITH_CAST]);
49 impl<'tcx> LateLintPass<'tcx> for PtrOffsetWithCast {
50 fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
51 // Check if the expressions is a ptr.offset or ptr.wrapping_offset method call
52 let (receiver_expr, arg_expr, method) = match expr_as_ptr_offset_call(cx, expr) {
53 Some(call_arg) => call_arg,
57 // Check if the argument to the method call is a cast from usize
58 let cast_lhs_expr = match expr_as_cast_from_usize(cx, arg_expr) {
59 Some(cast_lhs_expr) => cast_lhs_expr,
63 let msg = format!("use of `{}` with a `usize` casted to an `isize`", method);
64 if let Some(sugg) = build_suggestion(cx, method, receiver_expr, cast_lhs_expr) {
72 Applicability::MachineApplicable,
75 span_lint(cx, PTR_OFFSET_WITH_CAST, expr.span, &msg);
80 // If the given expression is a cast from a usize, return the lhs of the cast
81 fn expr_as_cast_from_usize<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
82 if let ExprKind::Cast(cast_lhs_expr, _) = expr.kind {
83 if is_expr_ty_usize(cx, cast_lhs_expr) {
84 return Some(cast_lhs_expr);
90 // If the given expression is a ptr::offset or ptr::wrapping_offset method call, return the
91 // receiver, the arg of the method call, and the method.
92 fn expr_as_ptr_offset_call<'tcx>(
93 cx: &LateContext<'tcx>,
95 ) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Method)> {
96 if let ExprKind::MethodCall(path_segment, _, [arg_0, arg_1, ..], _) = &expr.kind {
97 if is_expr_ty_raw_ptr(cx, arg_0) {
98 if path_segment.ident.name == sym::offset {
99 return Some((arg_0, arg_1, Method::Offset));
101 if path_segment.ident.name == sym!(wrapping_offset) {
102 return Some((arg_0, arg_1, Method::WrappingOffset));
109 // Is the type of the expression a usize?
110 fn is_expr_ty_usize<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
111 cx.typeck_results().expr_ty(expr) == cx.tcx.types.usize
114 // Is the type of the expression a raw pointer?
115 fn is_expr_ty_raw_ptr<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
116 cx.typeck_results().expr_ty(expr).is_unsafe_ptr()
119 fn build_suggestion<'tcx>(
120 cx: &LateContext<'tcx>,
122 receiver_expr: &Expr<'_>,
123 cast_lhs_expr: &Expr<'_>,
124 ) -> Option<String> {
125 let receiver = snippet_opt(cx, receiver_expr.span)?;
126 let cast_lhs = snippet_opt(cx, cast_lhs_expr.span)?;
127 Some(format!("{}.{}({})", receiver, method.suggestion(), cast_lhs))
130 #[derive(Copy, Clone)]
138 fn suggestion(self) -> &'static str {
140 Self::Offset => "add",
141 Self::WrappingOffset => "wrapping_add",
146 impl fmt::Display for Method {
147 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
149 Self::Offset => write!(f, "offset"),
150 Self::WrappingOffset => write!(f, "wrapping_offset"),