Add indexing for qualified imports

Author: purefunctor

crates/indexing/src/algorithm.rs

@@ -1,5 +1,5 @@
 use rowan::ast::AstChildren;
-use smol_str::SmolStr;
+use smol_str::{SmolStr, SmolStrBuilder};
 use syntax::cst;
 
 use crate::{
@@ -18,6 +18,12 @@ struct State {
 pub(super) fn index_module(module: &cst::Module) -> (IndexingResult, Vec<IndexingError>) {
     let mut state = State::default();
 
+    if let Some(imports) = module.imports() {
+        for import in imports.children() {
+            index_import(&mut state, import);
+        }
+    }
+
     if let Some(statements) = module.statements() {
         for statement in statements.children() {
             index_statement(&mut state, statement);
@@ -30,6 +36,26 @@ pub(super) fn index_module(module: &cst::Module) -> (IndexingResult, Vec<Indexin
     (result, errors)
 }
 
+fn index_import(state: &mut State, import: cst::ImportStatement) {
+    let import_id = state.source_map.insert_import(&import);
+
+    let Some(import_alias) = import.import_alias() else { return };
+    let Some(module_name) = import_alias.module_name() else { return };
+
+    let mut buffer = SmolStrBuilder::default();
+    if let Some(qualifier) = module_name.qualifier() {
+        if let Some(token) = qualifier.text() {
+            buffer.push_str(token.text());
+        }
+    }
+
+    let Some(token) = module_name.name_token() else { return };
+    buffer.push_str(token.text());
+
+    let name = buffer.finish();
+    state.nominal.insert_qualified(name, import_id);
+}
+
 fn index_statement(state: &mut State, declaration: cst::Declaration) {
     match declaration {
         cst::Declaration::ValueSignature(s) => {

crates/indexing/src/indexes.rs

@@ -1,7 +1,9 @@
 use indexmap::IndexMap;
 use smol_str::SmolStr;
 
-use crate::{id::Id, ClassMemberId, ConstructorId, DeclarationId, InstanceId, InstanceMemberId};
+use crate::{
+    id::Id, ClassMemberId, ConstructorId, DeclarationId, ImportId, InstanceId, InstanceMemberId,
+};
 
 /// A group of type signature and declaration.
 #[derive(Debug, Default, PartialEq, Eq)]
@@ -129,13 +131,18 @@ pub enum TypeItem {
 /// [`SourceMap`]: crate::SourceMap
 #[derive(Default)]
 pub struct NominalIndex {
+    qualified: IndexMap<SmolStr, Vec<ImportId>>,
     expr_item: IndexMap<SmolStr, ExprItem>,
     type_item: IndexMap<SmolStr, TypeItem>,
 }
 
 pub(crate) type MutableItem<'t, T> = (&'t mut T, Id<T>);
 
 impl NominalIndex {
+    pub(crate) fn insert_qualified(&mut self, name: SmolStr, import: ImportId) {
+        self.qualified.entry(name).or_default().push(import);
+    }
+
     pub(crate) fn expr_get_mut(&mut self, name: &str) -> Option<MutableItem<ExprItem>> {
         self.expr_item.get_full_mut(name).map(|(index, _, item)| (item, Id::from_raw(index)))
     }
@@ -164,6 +171,10 @@ impl NominalIndex {
 }
 
 impl NominalIndex {
+    pub fn lookup_qualified(&self, name: &str) -> Option<&[ImportId]> {
+        self.qualified.get(name).map(|v| &v[..])
+    }
+
     pub fn lookup_expr_item(&self, name: &str) -> Option<(ExprItemId, &ExprItem)> {
         self.expr_item.get_full(name).map(|(id, _, item)| (Id::from_raw(id), item))
     }

crates/indexing/src/sourcemap.rs

@@ -5,6 +5,9 @@ use syntax::cst;
 
 use crate::id::Id;
 
+pub type ImportId = Id<cst::ImportStatement>;
+pub type ImportPtr = AstPtr<cst::ImportStatement>;
+
 pub type DeclarationId = Id<cst::Declaration>;
 pub type DeclarationPtr = AstPtr<cst::Declaration>;
 
@@ -64,6 +67,7 @@ pub type InstanceMemberPtr = AstPtr<cst::InstanceMemberStatement>;
 /// implementation works well enough for the general case.
 #[derive(Debug, Default)]
 pub struct SourceMap {
+    imports: FxIndexSet<ImportPtr>,
     declaration: FxIndexSet<DeclarationPtr>,
     constructor: FxIndexSet<ConstructorPtr>,
     class_member: FxIndexSet<ClassMemberPtr>,
@@ -89,6 +93,10 @@ fn id<T: AstNode>(m: &FxIndexSet<AstPtr<T>>, ptr: AstPtr<T>) -> Option<Id<T>> {
 }
 
 impl SourceMap {
+    pub(crate) fn insert_import(&mut self, import: &cst::ImportStatement) -> ImportId {
+        insert(&mut self.imports, import)
+    }
+
     pub(crate) fn insert_declaration(&mut self, declaration: &cst::Declaration) -> DeclarationId {
         insert(&mut self.declaration, declaration)
     }
@@ -120,6 +128,14 @@ impl SourceMap {
 }
 
 impl SourceMap {
+    pub fn import_ptr(&self, id: ImportId) -> Option<ImportPtr> {
+        ptr(&self.imports, id)
+    }
+
+    pub fn import_id(&self, ptr: ImportPtr) -> Option<ImportId> {
+        id(&self.imports, ptr)
+    }
+
     pub fn declaration_ptr(&self, id: DeclarationId) -> Option<DeclarationPtr> {
         ptr(&self.declaration, id)
     }

crates/indexing/tests/indexing.rs

@@ -20,6 +20,10 @@ fn index<'s>(lines: impl AsRef<[&'s str]>) -> (cst::Module, IndexingResult, Inde
 #[test]
 fn well_formed_module() {
     let (_, index, _) = index([
+        "import Prelude as Prelude",
+        "import Data.List as Data.List",
+        "import Halogen as H",
+        "import Halogen.HTML as H",
         "id :: forall a. a -> a",
         "id x = x",
         "data Maybe :: Type -> Type",
@@ -44,6 +48,9 @@ fn well_formed_module() {
         "infix 5 type Eq as ==",
     ]);
 
+    let prelude = index.nominal.lookup_qualified("Prelude");
+    let data_list = index.nominal.lookup_qualified("Data.List");
+    let halogen = index.nominal.lookup_qualified("H");
     let id = index.nominal.lookup_expr_item("id");
     let maybe = index.nominal.lookup_type_item("Maybe");
     let just = index.nominal.lookup_expr_item("Just");
@@ -60,6 +67,9 @@ fn well_formed_module() {
     let type_equal = index.nominal.lookup_type_item("==");
 
     let mut snapshot = String::new();
+    writeln!(snapshot, "prelude: {:?}", prelude).unwrap();
+    writeln!(snapshot, "data_list: {:?}", data_list).unwrap();
+    writeln!(snapshot, "halogen: {:?}", halogen).unwrap();
     writeln!(snapshot, "id: {:?}", id).unwrap();
     writeln!(snapshot, "maybe: {:?}", maybe).unwrap();
     writeln!(snapshot, "just: {:?}", just).unwrap();

crates/indexing/tests/snapshots/indexing__well_formed_module.snap

@@ -3,6 +3,9 @@ source: crates/indexing/tests/indexing.rs
 expression: snapshot
 snapshot_kind: text
 ---
+prelude: Some([Id(0)])
+data_list: Some([Id(1)])
+halogen: Some([Id(2), Id(3)])
 id: Some((Id(0), Value(ValueGroupId { signature: Some(Id(0)), equations: [Id(1)] })))
 maybe: Some((Id(0), Data(TypeGroupId { signature: Some(Id(2)), declaration: Some(Id(3)), role: Some(Id(4)) })))
 just: Some((Id(1), Constructor(Id(0))))

crates/syntax/src/cst.rs

@@ -3,7 +3,19 @@ use rowan::ast::AstNode;
 #[macro_use]
 mod macros;
 
-create_cst_struct!(Module, ModuleHeader, ExportList);
+create_cst_struct!(Annotation, Qualifier);
+
+has_token!(
+    Annotation
+    | text() -> TEXT
+);
+
+has_token!(
+    Qualifier
+    | text() -> TEXT
+);
+
+create_cst_struct!(Module, ModuleHeader, ModuleName, ExportList);
 
 create_cst_enum!(
     ExportItem
@@ -171,9 +183,35 @@ create_cst_enum!(RecordUpdate | RecordUpdateLeaf | RecordUpdateBranch);
 
 has_child!(
     Module
+    | imports() -> ModuleImports
     | statements() -> ModuleStatements
 );
 
+has_children!(
+    ModuleImports
+    | children() -> ImportStatement
+);
+
+has_child!(
+    ImportStatement
+    | import_alias() -> ImportAlias
+);
+
+has_child!(
+    ImportAlias
+    | module_name() -> ModuleName
+);
+
+has_child!(
+    ModuleName
+    | qualifier() -> Qualifier
+);
+
+has_token!(
+    ModuleName
+    | name_token() -> UPPER
+);
+
 has_children!(
     ModuleStatements
     | children() -> Declaration