Add tests for insert()

Author: lionel-

Cargo.lock

@@ -66,6 +66,7 @@ tracing-error = "0.2.0"
 insta = { version = "1.39.0" }
 stdext = { path = "../stdext", features = ["testing"] }
 tempfile = "3.13.0"
+assert_matches = "1.5.0"
 
 [build-dependencies]
 cc = "1.1.22"

crates/ark/Cargo.toml

@@ -125,7 +125,12 @@ fn insert(path: &Path, entry: IndexEntry) -> anyhow::Result<()> {
     let path = str_from_path(path)?;
 
     let index = index.entry(path.to_string()).or_default();
+    index_insert(index, entry);
 
+    Ok(())
+}
+
+fn index_insert(index: &mut HashMap<String, IndexEntry>, entry: IndexEntry) {
     // We generally retain only the first occurrence in the index. In the
     // future we'll track every occurrences and their scopes but for now we
     // only track the first definition of an object (in a way, its
@@ -139,8 +144,6 @@ fn insert(path: &Path, entry: IndexEntry) -> anyhow::Result<()> {
     } else {
         index.insert(entry.key.clone(), entry);
     }
-
-    Ok(())
 }
 
 fn clear(path: &Path) -> anyhow::Result<()> {
@@ -408,7 +411,9 @@ fn index_comment(
 mod tests {
     use std::path::PathBuf;
 
+    use assert_matches::assert_matches;
     use insta::assert_debug_snapshot;
+    use tower_lsp::lsp_types;
 
     use super::*;
     use crate::lsp::documents::Document;
@@ -539,4 +544,67 @@ class <- R6::R6Class(
 "#
         );
     }
+
+    #[test]
+    fn test_index_insert_priority() {
+        let mut index = HashMap::new();
+
+        let section_entry = IndexEntry {
+            key: "foo".to_string(),
+            range: Range::new(
+                lsp_types::Position::new(0, 0),
+                lsp_types::Position::new(0, 3),
+            ),
+            data: IndexEntryData::Section {
+                level: 1,
+                title: "foo".to_string(),
+            },
+        };
+
+        let variable_entry = IndexEntry {
+            key: "foo".to_string(),
+            range: Range::new(
+                lsp_types::Position::new(1, 0),
+                lsp_types::Position::new(1, 3),
+            ),
+            data: IndexEntryData::Variable {
+                name: "foo".to_string(),
+            },
+        };
+
+        // The Variable has priority and should replace the Section
+        index_insert(&mut index, section_entry.clone());
+        index_insert(&mut index, variable_entry.clone());
+        assert_matches!(
+            &index.get("foo").unwrap().data,
+            IndexEntryData::Variable { name } => assert_eq!(name, "foo")
+        );
+
+        // Inserting a Section again with the same key does not override the Variable
+        index_insert(&mut index, section_entry.clone());
+        assert_matches!(
+            &index.get("foo").unwrap().data,
+            IndexEntryData::Variable { name } => assert_eq!(name, "foo")
+        );
+
+        let function_entry = IndexEntry {
+            key: "foo".to_string(),
+            range: Range::new(
+                lsp_types::Position::new(2, 0),
+                lsp_types::Position::new(2, 3),
+            ),
+            data: IndexEntryData::Function {
+                name: "foo".to_string(),
+                arguments: vec!["a".to_string()],
+            },
+        };
+
+        // Inserting another kind of variable (e.g., Function) with the same key
+        // does not override it either. The first occurrence is generally retained.
+        index_insert(&mut index, function_entry.clone());
+        assert_matches!(
+            &index.get("foo").unwrap().data,
+            IndexEntryData::Variable { name } => assert_eq!(name, "foo")
+        );
+    }
 }