Add diagnostic-item support for assert macros

Recognize `{static,const,build}_assert!` as special items, preferring
explicit `#[klint::diagnostic_item]` annotations and keeping a
conservative kernel-specific fallback for older trees.

The fallback resolves known macro paths structurally, extending the
existing diagnostic-item discovery pattern so later lints can identify
assert macros semantically.

Signed-off-by: Mohamad Alsadhan <mo@sdhn.cc>

Author: mqqz

src/diagnostic_items/out_of_band.rs

@@ -1,22 +1,30 @@
 //! Out-of-band attributes attached without source code changes.
 
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LOCAL_CRATE};
+use rustc_hir::def::DefKind;
+use rustc_hir::def::Res;
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::diagnostic_items::DiagnosticItems;
 use rustc_middle::middle::exported_symbols::ExportedSymbol;
 use rustc_middle::ty::TyCtxt;
+use rustc_span::Symbol;
 
 pub fn infer_missing_items<'tcx>(tcx: TyCtxt<'tcx>, items: &mut DiagnosticItems) {
-    if !items.name_to_id.contains_key(&crate::symbol::build_error) {
-        if let Some(def_id) = infer_build_error_diagnostic_item(tcx) {
-            super::collect_item(tcx, items, crate::symbol::build_error, def_id);
-        }
+    if !items.name_to_id.contains_key(&crate::symbol::build_error)
+        && let Some(def_id) = infer_build_error_diagnostic_item(tcx)
+    {
+        super::collect_item(tcx, items, crate::symbol::build_error, def_id);
     }
 
-    if !items.name_to_id.contains_key(&crate::symbol::c_str) {
-        if let Some(def_id) = infer_c_str_diagnostic_item(tcx) {
-            super::collect_item(tcx, items, crate::symbol::c_str, def_id);
-        }
+    if !items.name_to_id.contains_key(&crate::symbol::build_assert)
+        && let Some(def_id) = infer_build_assert_diagnostic_item(tcx)
+    {
+        super::collect_item(tcx, items, crate::symbol::build_assert, def_id);
+    }
+
+    if !items.name_to_id.contains_key(&crate::symbol::c_str)
+        && let Some(def_id) = infer_c_str_diagnostic_item(tcx)
+    {
+        super::collect_item(tcx, items, crate::symbol::c_str, def_id);
     }
 }
 
@@ -32,21 +40,89 @@ pub fn infer_build_error_diagnostic_item<'tcx>(tcx: TyCtxt<'tcx>) -> Option<DefI
     None
 }
 
-pub fn infer_c_str_diagnostic_item<'tcx>(tcx: TyCtxt<'tcx>) -> Option<DefId> {
+fn infer_local_macro_diagnostic_item<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    expected_path: &[PathSegment],
+) -> Option<DefId> {
+    let (root, rest) = expected_path.split_first()?;
+    let PathSegment::Type(root) = root else {
+        return None;
+    };
+
+    if *root != tcx.crate_name(LOCAL_CRATE) {
+        return None;
+    }
+
+    lookup_with_base(tcx, LOCAL_CRATE.as_def_id(), rest)
+}
+
+#[derive(Clone, Copy)]
+enum PathSegment {
+    Type(Symbol),
+    Macro(Symbol),
+}
+
+fn lookup_with_base<'tcx>(tcx: TyCtxt<'tcx>, base: DefId, path: &[PathSegment]) -> Option<DefId> {
+    let (segment, rest) = path.split_first()?;
+
+    let mut matches = tcx.module_children(base).iter().filter_map(|child| {
+        let Res::Def(kind, def_id) = child.res else {
+            return None;
+        };
+
+        match (*segment, kind, child.ident.name) {
+            (PathSegment::Type(expected), DefKind::Mod, actual) if actual == expected => {
+                Some(def_id)
+            }
+            (PathSegment::Macro(expected), DefKind::Macro(_), actual) if actual == expected => {
+                Some(def_id)
+            }
+            _ => None,
+        }
+    });
+
+    let def_id = matches.next()?;
+
+    if matches.next().is_some() {
+        return None;
+    }
+
+    if rest.is_empty() {
+        Some(def_id)
+    } else {
+        lookup_with_base(tcx, def_id, rest)
+    }
+}
+
+pub fn infer_build_assert_diagnostic_item<'tcx>(tcx: TyCtxt<'tcx>) -> Option<DefId> {
     let name = tcx.crate_name(LOCAL_CRATE);
 
     if name != crate::symbol::kernel {
         return None;
     }
 
-    let c_str = tcx
-        .module_children_local(CRATE_DEF_ID)
-        .iter()
-        .find(|c| {
-            c.ident.name == crate::symbol::c_str && matches!(c.res, Res::Def(DefKind::Macro(_), _))
-        })?
-        .res
-        .def_id();
+    infer_local_macro_diagnostic_item(
+        tcx,
+        &[
+            PathSegment::Type(crate::symbol::kernel),
+            PathSegment::Type(rustc_span::sym::prelude),
+            PathSegment::Macro(crate::symbol::build_assert),
+        ],
+    )
+}
+
+pub fn infer_c_str_diagnostic_item<'tcx>(tcx: TyCtxt<'tcx>) -> Option<DefId> {
+    let name = tcx.crate_name(LOCAL_CRATE);
+
+    if name != crate::symbol::kernel {
+        return None;
+    }
 
-    Some(c_str)
+    infer_local_macro_diagnostic_item(
+        tcx,
+        &[
+            PathSegment::Type(crate::symbol::kernel),
+            PathSegment::Macro(crate::symbol::c_str),
+        ],
+    )
 }

src/symbol.rs

@@ -55,6 +55,9 @@ def! {
     // Diagnostic items
     c_str,
     build_error,
+    build_assert,
+    const_assert,
+    static_assert,
 
     CONFIG_FRAME_WARN,
 }