feat: add is_mutable_raw_ptr and as_raw_ptr to hir::Type

Author: mehmet-yalcinkaya_volvo

Cargo.lock

@@ -41,6 +41,9 @@ expect-test.workspace = true
 tracing.workspace = true
 tracing-subscriber.workspace = true
 tracing-tree.workspace = true
+salsa.workspace = true
+salsa-macros.workspace = true
+triomphe.workspace = true
 
 # local deps
 test-utils.workspace = true

crates/hir/Cargo.toml

@@ -35,6 +35,9 @@ pub mod term_search;
 
 mod display;
 
+#[cfg(test)]
+mod test_db;
+
 #[doc(hidden)]
 pub use hir_def::ModuleId;
 
@@ -5693,6 +5696,16 @@ impl<'db> Type<'db> {
         matches!(self.ty.kind(), TyKind::RawPtr(..))
     }
 
+    pub fn is_mutable_raw_ptr(&self) -> bool {
+        matches!(self.ty.kind(), TyKind::RawPtr(.., hir_ty::next_solver::Mutability::Mut))
+    }
+
+    pub fn as_raw_ptr(&self) -> Option<(Type<'db>, Mutability)> {
+        let TyKind::RawPtr(ty, m) = self.ty.kind() else { return None };
+        let m = Mutability::from_mutable(matches!(m, hir_ty::next_solver::Mutability::Mut));
+        Some((self.derived(ty), m))
+    }
+
     pub fn remove_raw_ptr(&self) -> Option<Type<'db>> {
         if let TyKind::RawPtr(ty, _) = self.ty.kind() { Some(self.derived(ty)) } else { None }
     }
@@ -7159,3 +7172,99 @@ fn empty_param_env<'db>(krate: base_db::Crate) -> ParamEnvAndCrate<'db> {
 
 pub use hir_ty::next_solver;
 pub use hir_ty::setup_tracing;
+
+#[cfg(test)]
+mod tests {
+    use expect_test::{Expect, expect};
+    use syntax::AstNode;
+    use test_fixture::WithFixture;
+
+    use crate::{Semantics, test_db::TestDB};
+
+    fn check_raw_ptr_api(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {
+        let (db, file_id) = TestDB::with_single_file(ra_fixture);
+        let sema = Semantics::new(&db);
+        let source_file = sema.parse(file_id);
+
+        let mut buf = String::new();
+        for stmt in source_file.syntax().descendants().filter_map(syntax::ast::LetStmt::cast) {
+            let pat = stmt.pat().unwrap();
+            let ty = sema.type_of_pat(&pat).unwrap().original;
+            let name = pat.syntax().text().to_string();
+
+            buf += &format!("{name}: {{\n");
+            buf += &format!("  is_raw_ptr: {:?}\n", ty.is_raw_ptr());
+            buf += &format!("  is_mutable_raw_ptr: {:?}\n", ty.is_mutable_raw_ptr());
+            buf += &format!("  as_raw_ptr: {:?}\n", ty.as_raw_ptr().map(|(_, m)| m));
+            // Show the symmetry: reference API for comparison
+            buf += &format!("  is_reference: {:?}\n", ty.is_reference());
+            buf += &format!("  is_mutable_reference: {:?}\n", ty.is_mutable_reference());
+            buf += &format!("  as_reference: {:?}\n", ty.as_reference().map(|(_, m)| m));
+            buf += "}\n";
+        }
+        expect.assert_eq(buf.trim_end());
+    }
+
+    // Demonstrates the API gap that existed before this PR:
+    // `is_raw_ptr` could detect raw pointers, but there was no way to query
+    // their mutability — unlike references which had full `is_mutable_reference`
+    // and `as_reference` support. Users had to parse display strings as a workaround.
+    //
+    // After this PR, `is_mutable_raw_ptr` and `as_raw_ptr` fill the gap,
+    // making the raw pointer API symmetric with the reference API.
+    #[test]
+    fn raw_ptr_mutability_api() {
+        check_raw_ptr_api(
+            r#"
+fn test() {
+    let a: *const u32 = 0 as *const u32;
+    let b: *mut u32 = 0 as *mut u32;
+    let c: &u32 = &0u32;
+    let d: &mut u32 = &mut 0u32;
+    let e: u32 = 0u32;
+}
+"#,
+            expect![[r#"
+                a: {
+                  is_raw_ptr: true
+                  is_mutable_raw_ptr: false
+                  as_raw_ptr: Some(Shared)
+                  is_reference: false
+                  is_mutable_reference: false
+                  as_reference: None
+                }
+                b: {
+                  is_raw_ptr: true
+                  is_mutable_raw_ptr: true
+                  as_raw_ptr: Some(Mut)
+                  is_reference: false
+                  is_mutable_reference: false
+                  as_reference: None
+                }
+                c: {
+                  is_raw_ptr: false
+                  is_mutable_raw_ptr: false
+                  as_raw_ptr: None
+                  is_reference: true
+                  is_mutable_reference: false
+                  as_reference: Some(Shared)
+                }
+                d: {
+                  is_raw_ptr: false
+                  is_mutable_raw_ptr: false
+                  as_raw_ptr: None
+                  is_reference: true
+                  is_mutable_reference: true
+                  as_reference: Some(Mut)
+                }
+                e: {
+                  is_raw_ptr: false
+                  is_mutable_raw_ptr: false
+                  as_raw_ptr: None
+                  is_reference: false
+                  is_mutable_reference: false
+                  as_reference: None
+                }"#]],
+        );
+    }
+}

crates/hir/src/lib.rs

@@ -0,0 +1,134 @@
+//! Database used for testing `hir`.
+
+use std::{fmt, panic, sync::Mutex};
+
+use base_db::{
+    CrateGraphBuilder, CratesMap, FileSourceRootInput, FileText, Nonce, RootQueryDb,
+    SourceDatabase, SourceRoot, SourceRootId, SourceRootInput,
+};
+use hir_def::db::DefDatabase;
+#[allow(unused_imports)]
+use hir_ty::db::HirDatabase;
+use salsa::Durability;
+use triomphe::Arc;
+
+#[salsa_macros::db]
+pub(crate) struct TestDB {
+    storage: salsa::Storage<Self>,
+    files: Arc<base_db::Files>,
+    crates_map: Arc<CratesMap>,
+    events: Arc<Mutex<Option<Vec<salsa::Event>>>>,
+    nonce: Nonce,
+}
+
+impl Default for TestDB {
+    fn default() -> Self {
+        let events = <Arc<Mutex<Option<Vec<salsa::Event>>>>>::default();
+        let mut this = Self {
+            storage: salsa::Storage::new(Some(Box::new({
+                let events = events.clone();
+                move |event| {
+                    let mut events = events.lock().unwrap();
+                    if let Some(events) = &mut *events {
+                        events.push(event);
+                    }
+                }
+            }))),
+            events,
+            files: Default::default(),
+            crates_map: Default::default(),
+            nonce: Nonce::new(),
+        };
+        this.set_expand_proc_attr_macros_with_durability(true, Durability::HIGH);
+        this.set_all_crates(Arc::new(Box::new([])));
+        _ = base_db::LibraryRoots::builder(Default::default())
+            .durability(Durability::MEDIUM)
+            .new(&this);
+        _ = base_db::LocalRoots::builder(Default::default())
+            .durability(Durability::MEDIUM)
+            .new(&this);
+        CrateGraphBuilder::default().set_in_db(&mut this);
+        this
+    }
+}
+
+impl Clone for TestDB {
+    fn clone(&self) -> Self {
+        Self {
+            storage: self.storage.clone(),
+            files: self.files.clone(),
+            crates_map: self.crates_map.clone(),
+            events: self.events.clone(),
+            nonce: Nonce::new(),
+        }
+    }
+}
+
+impl fmt::Debug for TestDB {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TestDB").finish()
+    }
+}
+
+#[salsa_macros::db]
+impl SourceDatabase for TestDB {
+    fn file_text(&self, file_id: base_db::FileId) -> FileText {
+        self.files.file_text(file_id)
+    }
+
+    fn set_file_text(&mut self, file_id: base_db::FileId, text: &str) {
+        let files = Arc::clone(&self.files);
+        files.set_file_text(self, file_id, text);
+    }
+
+    fn set_file_text_with_durability(
+        &mut self,
+        file_id: base_db::FileId,
+        text: &str,
+        durability: Durability,
+    ) {
+        let files = Arc::clone(&self.files);
+        files.set_file_text_with_durability(self, file_id, text, durability);
+    }
+
+    fn source_root(&self, source_root_id: SourceRootId) -> SourceRootInput {
+        self.files.source_root(source_root_id)
+    }
+
+    fn set_source_root_with_durability(
+        &mut self,
+        source_root_id: SourceRootId,
+        source_root: Arc<SourceRoot>,
+        durability: Durability,
+    ) {
+        let files = Arc::clone(&self.files);
+        files.set_source_root_with_durability(self, source_root_id, source_root, durability);
+    }
+
+    fn file_source_root(&self, id: base_db::FileId) -> FileSourceRootInput {
+        self.files.file_source_root(id)
+    }
+
+    fn set_file_source_root_with_durability(
+        &mut self,
+        id: base_db::FileId,
+        source_root_id: SourceRootId,
+        durability: Durability,
+    ) {
+        let files = Arc::clone(&self.files);
+        files.set_file_source_root_with_durability(self, id, source_root_id, durability);
+    }
+
+    fn crates_map(&self) -> Arc<CratesMap> {
+        self.crates_map.clone()
+    }
+
+    fn nonce_and_revision(&self) -> (Nonce, salsa::Revision) {
+        (self.nonce, salsa::plumbing::ZalsaDatabase::zalsa(self).current_revision())
+    }
+}
+
+#[salsa_macros::db]
+impl salsa::Database for TestDB {}
+
+impl panic::RefUnwindSafe for TestDB {}