Initial indexing for exported items

Author: purefunctor

crates/indexing/src/algorithm.rs

@@ -1,17 +1,19 @@
 use rowan::ast::AstChildren;
 use smol_str::{SmolStr, SmolStrBuilder};
-use syntax::cst;
+use syntax::{cst, SyntaxToken};
 
 use crate::{
-    ClassMemberId, ConstructorId, Duplicate, ExprItem, IndexingError, IndexingResult, InstanceId,
-    NominalIndex, RelationalIndex, SourceMap, TypeGroupId, TypeItem, TypeItemId, ValueGroupId,
+    ClassMemberId, ConstructorId, Duplicate, ExportIndex, ExprItem, IndexingError, IndexingResult,
+    InstanceId, NominalIndex, RelationalIndex, SourceMap, TypeGroupId, TypeItem, TypeItemId,
+    ValueGroupId,
 };
 
 #[derive(Default)]
 struct State {
     source_map: SourceMap,
     nominal: NominalIndex,
     relational: RelationalIndex,
+    export: ExportIndex,
     errors: Vec<IndexingError>,
 }
 
@@ -30,12 +32,90 @@ pub(super) fn index_module(module: &cst::Module) -> (IndexingResult, Vec<Indexin
         }
     }
 
-    let State { source_map, nominal, relational, errors } = state;
-    let result = IndexingResult { source_map, nominal, relational };
+    if let Some(header) = module.header() {
+        if let Some(exports) = header.exports() {
+            for export in exports.children() {
+                index_export(&mut state, export);
+            }
+        }
+    }
+
+    let State { source_map, nominal, relational, export, errors } = state;
+    let result = IndexingResult { source_map, nominal, relational, export };
 
     (result, errors)
 }
 
+fn index_export(state: &mut State, export: cst::ExportItem) {
+    let export_id = state.source_map.insert_export(&export);
+
+    let index_expr = |state: &mut State, token: SyntaxToken| {
+        let name = token.text();
+        if let Some(existing) = state.export.lookup_expr_export(name) {
+            let duplicate = export_id;
+            state.errors.push(IndexingError::DuplicateExport { existing, duplicate });
+        } else {
+            let name = SmolStr::from(name);
+            state.export.insert_expr_export(name, export_id);
+        }
+    };
+
+    let index_type = |state: &mut State, token: SyntaxToken| {
+        let name = token.text();
+        if let Some(existing) = state.export.lookup_type_export(name) {
+            let duplicate = export_id;
+            state.errors.push(IndexingError::DuplicateExport { existing, duplicate });
+        } else {
+            let name = SmolStr::from(name);
+            state.export.insert_type_export(name, export_id);
+        }
+    };
+
+    match export {
+        cst::ExportItem::ExportValue(v) => {
+            let Some(token) = v.name_token() else { return };
+            index_expr(state, token);
+        }
+        cst::ExportItem::ExportClass(c) => {
+            let Some(token) = c.name_token() else { return };
+            index_type(state, token)
+        }
+        cst::ExportItem::ExportType(t) => {
+            let Some(token) = t.name_token() else { return };
+            index_type(state, token);
+        }
+        cst::ExportItem::ExportOperator(o) => {
+            let Some(token) = o.name_token() else { return };
+            index_expr(state, token);
+        }
+        cst::ExportItem::ExportTypeOperator(o) => {
+            let Some(token) = o.name_token() else { return };
+            index_type(state, token);
+        }
+        cst::ExportItem::ExportModule(m) => {
+            let Some(module_name) = m.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();
+            if let Some(existing) = state.export.lookup_module_export(&name) {
+                let duplicate = export_id;
+                state.errors.push(IndexingError::DuplicateExport { existing, duplicate });
+            } else {
+                state.export.insert_module_export(name, export_id);
+            }
+        }
+    }
+}
+
 fn index_import(state: &mut State, import: cst::ImportStatement) {
     let import_id = state.source_map.insert_import(&import);
 

crates/indexing/src/error.rs

@@ -1,8 +1,12 @@
-use crate::{ClassMemberId, ConstructorId, DeclarationId, ExprItemId, InstanceId, TypeItemId};
+use crate::{
+    ClassMemberId, ConstructorId, DeclarationId, ExportItemId, ExprItemId, InstanceId, TypeItemId,
+};
 
 /// Errors emitted during indexing.
 #[derive(Debug, PartialEq, Eq)]
 pub enum IndexingError {
+    DuplicateExport { existing: ExportItemId, duplicate: ExportItemId },
+
     DuplicateExprItem { item_id: ExprItemId, duplicate: Duplicate },
     DuplicateTypeItem { item_id: TypeItemId, duplicate: Duplicate },
 

crates/indexing/src/indexes.rs

@@ -1,7 +1,11 @@
 use indexmap::IndexMap;
+use rustc_hash::FxHashMap;
 use smol_str::SmolStr;
 
-use crate::{ClassMemberId, ConstructorId, DeclarationId, ImportId, InstanceId, InstanceMemberId};
+use crate::{
+    ClassMemberId, ConstructorId, DeclarationId, ExportItemId, ImportId, InstanceId,
+    InstanceMemberId,
+};
 use id::Id;
 
 /// A group of type signature and declaration.
@@ -242,3 +246,38 @@ impl RelationalIndex {
         find_t(&self.class_member_of, id)
     }
 }
+
+#[derive(Debug, Default)]
+pub struct ExportIndex {
+    module_export: FxHashMap<SmolStr, ExportItemId>,
+    expr_export: FxHashMap<SmolStr, ExportItemId>,
+    type_export: FxHashMap<SmolStr, ExportItemId>,
+}
+
+impl ExportIndex {
+    pub fn lookup_module_export(&self, name: &str) -> Option<ExportItemId> {
+        self.module_export.get(name).copied()
+    }
+
+    pub fn lookup_expr_export(&self, name: &str) -> Option<ExportItemId> {
+        self.expr_export.get(name).copied()
+    }
+
+    pub fn lookup_type_export(&self, name: &str) -> Option<ExportItemId> {
+        self.type_export.get(name).copied()
+    }
+}
+
+impl ExportIndex {
+    pub(crate) fn insert_module_export(&mut self, name: SmolStr, id: ExportItemId) {
+        self.module_export.insert(name, id);
+    }
+
+    pub(crate) fn insert_expr_export(&mut self, name: SmolStr, id: ExportItemId) {
+        self.expr_export.insert(name, id);
+    }
+
+    pub(crate) fn insert_type_export(&mut self, name: SmolStr, id: ExportItemId) {
+        self.type_export.insert(name, id);
+    }
+}

crates/indexing/src/lib.rs

@@ -16,6 +16,7 @@ use syntax::cst;
 pub struct IndexingResult {
     pub source_map: SourceMap,
     pub nominal: NominalIndex,
+    pub export: ExportIndex,
     pub relational: RelationalIndex,
 }
 

crates/indexing/src/sourcemap.rs

@@ -23,6 +23,9 @@ pub type InstancePtr = AstPtr<cst::InstanceDeclaration>;
 pub type InstanceMemberId = Id<cst::InstanceMemberStatement>;
 pub type InstanceMemberPtr = AstPtr<cst::InstanceMemberStatement>;
 
+pub type ExportItemId = Id<cst::ExportItem>;
+pub type ExportItemPtr = AstPtr<cst::ExportItem>;
+
 /// Mapping from module items to stable IDs.
 ///
 /// The `SourceMap` derives stable [`Id`] values from [`AstPtr`] in the CST.
@@ -67,6 +70,7 @@ pub type InstanceMemberPtr = AstPtr<cst::InstanceMemberStatement>;
 /// implementation works well enough for the general case.
 #[derive(Debug, Default)]
 pub struct SourceMap {
+    exports: FxIndexSet<ExportItemPtr>,
     imports: FxIndexSet<ImportPtr>,
     declaration: FxIndexSet<DeclarationPtr>,
     constructor: FxIndexSet<ConstructorPtr>,
@@ -94,6 +98,10 @@ fn id<T: AstNode>(m: &FxIndexSet<AstPtr<T>>, ptr: AstPtr<T>) -> Option<Id<T>> {
 }
 
 impl SourceMap {
+    pub(crate) fn insert_export(&mut self, export: &cst::ExportItem) -> ExportItemId {
+        insert(&mut self.exports, export)
+    }
+
     pub(crate) fn insert_import(&mut self, import: &cst::ImportStatement) -> ImportId {
         insert(&mut self.imports, import)
     }
@@ -129,6 +137,14 @@ impl SourceMap {
 }
 
 impl SourceMap {
+    pub fn export_ptr(&self, id: ExportItemId) -> Option<ExportItemPtr> {
+        ptr(&self.exports, id)
+    }
+
+    pub fn export_id(&self, ptr: ExportItemPtr) -> Option<ExportItemId> {
+        id(&self.exports, ptr)
+    }
+
     pub fn import_ptr(&self, id: ImportId) -> Option<ImportPtr> {
         ptr(&self.imports, id)
     }

crates/indexing/tests/indexing.rs

@@ -4,9 +4,7 @@ use indexing::{IndexingErrors, IndexingResult};
 use rowan::ast::AstNode;
 use syntax::cst;
 
-fn index<'s>(lines: impl AsRef<[&'s str]>) -> (cst::Module, IndexingResult, IndexingErrors) {
-    let source = format!("module Main where\n{}", lines.as_ref().join("\n"));
-
+fn index_source(source: &str) -> (cst::Module, IndexingResult, IndexingErrors) {
     let lexed = lexing::lex(&source);
     let tokens = lexing::layout(&lexed);
 
@@ -17,6 +15,11 @@ fn index<'s>(lines: impl AsRef<[&'s str]>) -> (cst::Module, IndexingResult, Inde
     (module, index, errors)
 }
 
+fn index<'s>(lines: impl AsRef<[&'s str]>) -> (cst::Module, IndexingResult, IndexingErrors) {
+    let source = format!("module Main where\n{}", lines.as_ref().join("\n"));
+    index_source(&source)
+}
+
 #[test]
 fn well_formed_module() {
     let (_, index, _) = index([
@@ -197,3 +200,21 @@ fn type_role_errors() {
     ]);
     insta::assert_debug_snapshot!(errors);
 }
+
+#[test]
+fn index_export() {
+    let (_, index, errors) = index_source(
+        "module Main (life, class Eq, Synonym, Data(..), (+), type (+), module Export) where\n",
+    );
+
+    insta::assert_debug_snapshot!((index, errors));
+}
+
+#[test]
+fn index_export_duplicate() {
+    let (_, index, errors) = index_source(
+        "module Main (life, life, class Eq, class Eq, Synonym, Synonym, Data(..), Data(..), (+), (+), type (+), type (+), module Export, module Export)"
+    );
+
+    insta::assert_debug_snapshot!((index, errors));
+}

crates/indexing/tests/snapshots/indexing__index_export.snap

@@ -0,0 +1,102 @@
+---
+source: crates/indexing/tests/indexing.rs
+expression: "(index, errors)"
+snapshot_kind: text
+---
+(
+    IndexingResult {
+        source_map: SourceMap {
+            exports: {
+                AstPtr {
+                    raw: SyntaxNodePtr {
+                        kind: ExportValue,
+                        range: 13..17,
+                    },
+                },
+                AstPtr {
+                    raw: SyntaxNodePtr {
+                        kind: ExportClass,
+                        range: 18..27,
+                    },
+                },
+                AstPtr {
+                    raw: SyntaxNodePtr {
+                        kind: ExportType,
+                        range: 28..36,
+                    },
+                },
+                AstPtr {
+                    raw: SyntaxNodePtr {
+                        kind: ExportType,
+                        range: 37..46,
+                    },
+                },
+                AstPtr {
+                    raw: SyntaxNodePtr {
+                        kind: ExportOperator,
+                        range: 47..51,
+                    },
+                },
+                AstPtr {
+                    raw: SyntaxNodePtr {
+                        kind: ExportTypeOperator,
+                        range: 52..61,
+                    },
+                },
+                AstPtr {
+                    raw: SyntaxNodePtr {
+                        kind: ExportModule,
+                        range: 62..76,
+                    },
+                },
+            },
+            imports: {},
+            declaration: {},
+            constructor: {},
+            class_member: {},
+            instance: {},
+            instance_member: {},
+        },
+        nominal: NominalIndex {
+            qualified: {},
+            expr_item: {},
+            type_item: {},
+        },
+        export: ExportIndex {
+            module_export: {
+                "Export": Id(
+                    6,
+                ),
+            },
+            expr_export: {
+                "(+)": Id(
+                    4,
+                ),
+                "life": Id(
+                    0,
+                ),
+            },
+            type_export: {
+                "(+)": Id(
+                    5,
+                ),
+                "Synonym": Id(
+                    2,
+                ),
+                "Eq": Id(
+                    1,
+                ),
+                "Data": Id(
+                    3,
+                ),
+            },
+        },
+        relational: RelationalIndex {
+            constructor_of: [],
+            class_member_of: [],
+            instance_of: [],
+            instance_member_of: [],
+        },
+    },
+    [],
+)