simpler version

Author: Soveu

clippy_lints/src/pointer_in_nomem_asm_block.rs

@@ -2,61 +2,57 @@ use rustc_hir::*;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_ast::InlineAsmOptions;
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_span::{BytePos, Span};
+use rustc_errors::Applicability;
 
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum AsmMemoryOptions {
-    NoMem,
-    Readonly,
-}
-
-fn has_in_operand_pointer(cx: &LateContext<'_>, asm_op: &InlineAsmOperand<'_>) -> Option<Mutability> {
+fn has_in_operand_pointer(cx: &LateContext<'_>, asm_op: &InlineAsmOperand<'_>) -> bool {
     let asm_in_expr = match asm_op {
+        InlineAsmOperand::SymStatic { .. }
+        | InlineAsmOperand::Out { .. }
+        | InlineAsmOperand::Const { .. }
+        | InlineAsmOperand::SymFn { .. }
+        | InlineAsmOperand::Label { .. } => return false,
         InlineAsmOperand::In { expr, .. } => expr,
         InlineAsmOperand::InOut { expr, .. } => expr,
         InlineAsmOperand::SplitInOut { in_expr, ..} => in_expr,
-        InlineAsmOperand::SymStatic { .. } => return Some(Mutability::Not),
-        InlineAsmOperand::Out { .. } => return None,
-        InlineAsmOperand::Const { .. } => return None,
-        InlineAsmOperand::SymFn { .. } => return None,
-        InlineAsmOperand::Label { .. } => return None,
     };
 
     return match cx.typeck_results().expr_ty(asm_in_expr).kind() {
-        rustc_middle::ty::TyKind::RawPtr(_, mutbl) => Some(*mutbl),
-        rustc_middle::ty::TyKind::Ref(_, _, mutbl) => Some(*mutbl),
-        _ => None,
+        rustc_middle::ty::TyKind::RawPtr(..) => true,
+        rustc_middle::ty::TyKind::Ref(..) => true,
+        _ => false,
     };
 }
 
-fn yeet_lint(cx: &LateContext<'_>, span: rustc_span::Span, msg: &'static str) {
-    span_lint(cx, POINTER_IN_NOMEM_ASM_BLOCK, span, msg);
+fn shift_span_by_two_bytes(s: Span) -> Span {
+    s.with_lo(s.lo() + BytePos(2))
 }
 
-fn check_asm(cx: &LateContext<'_>, asm: &InlineAsm<'_>) {
-    let nomem = asm.options.contains(InlineAsmOptions::NOMEM);
-    let rdonly = asm.options.contains(InlineAsmOptions::READONLY);
-    let memopt = match (nomem, rdonly) {
-        (false, false) => return, // nothing to check
-        (false, true) => AsmMemoryOptions::Readonly,
-        (true, false) => AsmMemoryOptions::NoMem,
-        (true, true) => return, // just return, rustc should fail anyway
-    };
+fn yeet_lint(cx: &LateContext<'_>, asm: &InlineAsm<'_>, asm_span: Span, op_spans: Vec<Span>) {
+    let last_op_span = asm.operands.last().unwrap().1;
+    let probably_asm_options_span = asm_span.trim_start(last_op_span).map(shift_span_by_two_bytes);
 
-    for (asm_op, asm_op_span) in asm.operands {
-        let p = match has_in_operand_pointer(cx, asm_op) {
-            Some(p) => p,
-            None => continue,
-        };
+    span_lint_and_then(cx, POINTER_IN_NOMEM_ASM_BLOCK, op_spans, "passing pointer to nomem asm block", |diag| {
+        if let Some(probably_asm_options_span) = probably_asm_options_span {
+            diag.span_suggestion(probably_asm_options_span, "heeelppp", "suggg", Applicability::MaybeIncorrect);
+        }
+        // note_span.inspect(|s| { diag.span_note(*s, "declared here"); });
+    });
+}
+
+fn check_asm(cx: &LateContext<'_>, asm: &InlineAsm<'_>, asm_span: Span) {
+    if !asm.options.contains(InlineAsmOptions::NOMEM) || asm.operands.is_empty() {
+        return;
+    }
 
-        let msg = match (p, memopt) {
-            (Mutability::Not, AsmMemoryOptions::Readonly) => continue,
-            (Mutability::Not, AsmMemoryOptions::NoMem) => "const pointer in nomem",
-            (Mutability::Mut, AsmMemoryOptions::Readonly) => "mut pointer in readonly",
-            (Mutability::Mut, AsmMemoryOptions::NoMem) => "mut pointer in nomem",
-        };
+    let spans = asm.operands.iter()
+        .filter(|(op, _span)| has_in_operand_pointer(cx, op))
+        .map(|(_op, span)| *span)
+        .collect::<Vec<Span>>();
 
-        yeet_lint(cx, *asm_op_span, msg);
+    if !spans.is_empty() {
+        yeet_lint(cx, asm, asm_span, spans);
     }
 }
 
@@ -84,7 +80,7 @@ declare_lint_pass!(PointerInNomemAsmBlock => [POINTER_IN_NOMEM_ASM_BLOCK]);
 impl<'tcx> LateLintPass<'tcx> for PointerInNomemAsmBlock {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
         if let ExprKind::InlineAsm(asm) = &expr.kind {
-            check_asm(cx, asm);
+            check_asm(cx, asm, expr.span);
         }
     }
 }

tests/ui/pointer_in_nomem_asm_block.rs

@@ -3,7 +3,13 @@
 #![no_std]
 
 unsafe fn nomem_bad(p: &i32) {
-    core::arch::asm!("asdf {p}", p = in(reg) p, options(nomem, nostack, preserves_flags));
+    core::arch::asm!(
+        "asdf {p1}, {p2}, {p3}",
+        p1 = in(reg) p,
+        p2 = in(reg) p as *const _ as usize,
+        p3 = in(reg) p,
+        options(nomem, nostack, preserves_flags)
+    );
 }
 
 unsafe fn readonly_bad(p: &mut i32) {