feat(hir): resolve checker and covergroup members

Author: hongjr03

crates/hir/src/container.rs

@@ -11,6 +11,8 @@ use crate::{
     hir_def::{
         aggregate::{StructDef, StructId, StructSrc},
         block::{Block, BlockId, BlockInfo, BlockSourceMap, BlockSrc, LocalBlockId},
+        checker::CheckerId,
+        covergroup::CovergroupId,
         declaration::{Declaration, DeclarationId, DeclarationSrc},
         expr::{
             Expr, ExprId, ExprSrc,
@@ -40,6 +42,83 @@ define_enum_deriving_from! {
         Block(BlockId),
         Subroutine(SubroutineScope),
         ClockingBlock(InModule<ClockingBlockId>),
+        Checker(InFileOrModule<CheckerId>),
+        Covergroup(InFileOrModule<CovergroupId>),
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
+pub struct InFileOrModule<T> {
+    pub value: T,
+    pub cont_id: FileOrModule,
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
+pub enum FileOrModule {
+    File(HirFileId),
+    Module(ModuleId),
+}
+
+impl<T> InFileOrModule<T> {
+    pub fn new(cont_id: FileOrModule, value: T) -> Self {
+        Self { value, cont_id }
+    }
+
+    pub fn parent_scope(&self) -> ScopeId {
+        self.cont_id.into()
+    }
+
+    pub fn as_in_container(self) -> InContainer<T> {
+        InContainer::new(self.cont_id.into(), self.value)
+    }
+}
+
+impl FileOrModule {
+    pub fn file_id(self) -> FileId {
+        match self {
+            FileOrModule::File(file_id) => file_id.file_id(),
+            FileOrModule::Module(module_id) => module_id.file_id(),
+        }
+    }
+}
+
+impl From<FileOrModule> for ScopeId {
+    fn from(cont_id: FileOrModule) -> Self {
+        match cont_id {
+            FileOrModule::File(file_id) => file_id.into(),
+            FileOrModule::Module(module_id) => module_id.into(),
+        }
+    }
+}
+
+impl TryFrom<ScopeId> for FileOrModule {
+    type Error = ();
+
+    fn try_from(cont_id: ScopeId) -> Result<Self, Self::Error> {
+        match cont_id {
+            ScopeId::File(file_id) => Ok(Self::File(file_id)),
+            ScopeId::Module(module_id) => Ok(Self::Module(module_id)),
+            ScopeId::GenerateBlock(_)
+            | ScopeId::Block(_)
+            | ScopeId::Subroutine(_)
+            | ScopeId::ClockingBlock(_)
+            | ScopeId::Checker(_)
+            | ScopeId::Covergroup(_) => Err(()),
+        }
+    }
+}
+
+impl<T> TryFrom<InContainer<T>> for InFileOrModule<T> {
+    type Error = ();
+
+    fn try_from(item: InContainer<T>) -> Result<Self, Self::Error> {
+        Ok(Self::new(FileOrModule::try_from(item.cont_id)?, item.value))
+    }
+}
+
+impl<T> From<InFileOrModule<T>> for InContainer<T> {
+    fn from(item: InFileOrModule<T>) -> Self {
+        item.as_in_container()
     }
 }
 
@@ -96,7 +175,11 @@ impl TryFrom<ScopeId> for SubroutineParent {
             ScopeId::File(file_id) => Ok(Self::File(file_id)),
             ScopeId::Module(module_id) => Ok(Self::Module(module_id)),
             ScopeId::GenerateBlock(generate_block_id) => Ok(Self::GenerateBlock(generate_block_id)),
-            ScopeId::Block(_) | ScopeId::Subroutine(_) | ScopeId::ClockingBlock(_) => Err(()),
+            ScopeId::Block(_)
+            | ScopeId::Subroutine(_)
+            | ScopeId::ClockingBlock(_)
+            | ScopeId::Checker(_)
+            | ScopeId::Covergroup(_) => Err(()),
         }
     }
 }
@@ -205,6 +288,8 @@ impl ScopeId {
             ScopeId::Block(_) => ScopeKind::Block,
             ScopeId::Subroutine(_) => ScopeKind::Subroutine,
             ScopeId::ClockingBlock(_) => ScopeKind::ClockingBlock,
+            ScopeId::Checker(_) => ScopeKind::Checker,
+            ScopeId::Covergroup(_) => ScopeKind::Covergroup,
         }
     }
 
@@ -216,6 +301,8 @@ impl ScopeId {
             ScopeId::Block(block_id) => block_id.file_id(db),
             ScopeId::Subroutine(subroutine) => subroutine.file_id(db),
             ScopeId::ClockingBlock(clocking_block) => clocking_block.module_id.file_id(),
+            ScopeId::Checker(checker) => checker.cont_id.file_id(),
+            ScopeId::Covergroup(covergroup) => covergroup.cont_id.file_id(),
         }
     }
 
@@ -229,6 +316,12 @@ impl ScopeId {
             ScopeId::ClockingBlock(_) => {
                 panic!("clocking block scopes do not expose a generic HIR container")
             }
+            ScopeId::Checker(_) => {
+                panic!("checker scopes do not expose a generic HIR container")
+            }
+            ScopeId::Covergroup(_) => {
+                panic!("covergroup scopes do not expose a generic HIR container")
+            }
         }
     }
 
@@ -246,6 +339,12 @@ impl ScopeId {
             ScopeId::ClockingBlock(_) => {
                 panic!("clocking block scopes do not expose a generic source map")
             }
+            ScopeId::Checker(_) => {
+                panic!("checker scopes do not expose a generic source map")
+            }
+            ScopeId::Covergroup(_) => {
+                panic!("covergroup scopes do not expose a generic source map")
+            }
         }
     }
 }
@@ -396,6 +495,8 @@ impl Iterator for ScopeParent<'_> {
             ScopeId::Block(block_id) => Some(block_id.lookup(self.db).cont_id),
             ScopeId::Subroutine(subroutine) => Some(subroutine.parent_scope()),
             ScopeId::ClockingBlock(clocking_block) => Some(clocking_block.module_id.into()),
+            ScopeId::Checker(checker) => Some(checker.parent_scope()),
+            ScopeId::Covergroup(covergroup) => Some(covergroup.parent_scope()),
         };
         next
     }

crates/hir/src/db.rs

@@ -8,6 +8,8 @@ use crate::{
     file::HirFileId,
     hir_def::{
         block::{self, Block, BlockId, BlockLoc, BlockSourceMap},
+        checker::CheckerId,
+        covergroup::CovergroupId,
         expr::{
             ExprId,
             data_ty::{BuiltinDataTy, BuiltinDataTyId},
@@ -124,6 +126,12 @@ pub trait HirDb: InternDb {
     #[salsa::invoke(NameScope::clocking_block_scope_query)]
     fn clocking_block_scope(&self, clocking_block_id: InModule<ClockingBlockId>) -> Arc<NameScope>;
 
+    #[salsa::invoke(NameScope::checker_scope_query)]
+    fn checker_scope(&self, checker_id: InContainer<CheckerId>) -> Arc<NameScope>;
+
+    #[salsa::invoke(NameScope::covergroup_scope_query)]
+    fn covergroup_scope(&self, covergroup_id: InContainer<CovergroupId>) -> Arc<NameScope>;
+
     #[salsa::invoke(NameScope::generate_block_scope_query)]
     fn generate_block_scope(&self, generate_block_id: GenerateBlockId) -> Arc<NameScope>;