feat: add data structure for dependency resolution

Author: LesterEvSe

src/parse.rs

@@ -2385,6 +2385,19 @@ impl crate::ArbitraryRec for Match {
 mod test {
     use super::*;
 
+    impl UseDecl {
+        /// Creates a dummy `UseDecl` specifically for testing `DependencyMap` resolution.
+        /// It automatically builds the internal Identifier path.
+        pub fn dummy_path(path: Vec<Identifier>) -> Self {
+            Self {
+                visibility: Visibility::default(),
+                path,
+                items: UseItems::List(Vec::new()),
+                span: Span::new(0, 0),
+            }
+        }
+    }
+
     #[test]
     fn test_reject_redefined_builtin_type() {
         let ty = TypeAlias::parse_from_str("type Ctx8 = u32")

src/resolution.rs

@@ -1,6 +1,10 @@
-use std::path::Path;
+use std::io;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
+use crate::error::{Error, RichError, WithSpan as _};
+use crate::parse::UseDecl;
+
 /// Powers error reporting by mapping compiler diagnostics to the specific file.
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct SourceFile {
@@ -44,3 +48,259 @@ impl SourceFile {
         self.content.clone()
     }
 }
+
+/// This defines how a specific dependency root path (e.g. "math")
+/// should be resolved to a physical path on the disk, restricted to
+/// files executing within the `context_prefix`.
+#[derive(Debug, Clone)]
+pub struct Remapping {
+    /// The base directory that owns this dependency mapping.
+    pub context_prefix: PathBuf,
+    /// The name used in the `use` statement (e.g., "math").
+    pub dependency_root_path: String,
+    /// The physical path this dependency root path points to.
+    pub target: PathBuf,
+}
+
+/// A router for resolving dependencies across multi-file workspaces.
+///
+/// Mappings are strictly sorted by the longest `context_prefix` match.
+/// This mathematical guarantee ensures that if multiple nested directories
+/// define the same dependency root path, the most specific (deepest) context wins.
+#[derive(Debug, Default)]
+pub struct DependencyMap {
+    inner: Vec<Remapping>,
+}
+
+impl DependencyMap {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
+    /// Re-sort the vector in descending order so the longest context paths are always at the front.
+    /// This mathematically guarantees that the first match we find is the most specific.
+    fn sort_mappings(&mut self) {
+        self.inner.sort_by(|a, b| {
+            let len_a = a.context_prefix.as_os_str().len();
+            let len_b = b.context_prefix.as_os_str().len();
+            len_b.cmp(&len_a)
+        });
+    }
+
+    /// Add a dependency mapped to a specific calling file's path prefix.
+    /// Re-sorts the vector internally to guarantee the Longest Prefix Match.
+    pub fn insert(
+        &mut self,
+        context: &Path,
+        dependency_root_path: String,
+        path: &Path,
+    ) -> io::Result<()> {
+        let canon_context = std::fs::canonicalize(context).map_err(|err| {
+            io::Error::new(
+                err.kind(),
+                format!(
+                    "Failed to find context directory '{}': {}",
+                    context.display(),
+                    err
+                ),
+            )
+        })?;
+
+        let canon_path = std::fs::canonicalize(path).map_err(|err| {
+            io::Error::new(
+                err.kind(),
+                format!(
+                    "Failed to find library target path '{}': {}",
+                    path.display(),
+                    err
+                ),
+            )
+        })?;
+
+        self.inner.push(Remapping {
+            context_prefix: canon_context,
+            dependency_root_path,
+            target: canon_path,
+        });
+
+        self.sort_mappings();
+
+        Ok(())
+    }
+
+    /// Resolve `use dependency_root_path::...` into a physical file path by finding the
+    /// most specific library context that owns the current file.
+    pub fn resolve_path(
+        &self,
+        current_file: &Path,
+        use_decl: &UseDecl,
+    ) -> Result<PathBuf, RichError> {
+        // Safely extract the first segment (the dependency root path)
+        let parts: Vec<&str> = use_decl.path().iter().map(|s| s.as_inner()).collect();
+        let first_segment = parts.first().copied().ok_or_else(|| {
+            Error::CannotParse("Empty use path".to_string()).with_span(*use_decl.span())
+        })?;
+
+        // Because the vector is sorted by longest prefix,
+        // the VERY FIRST match we find is guaranteed to be the correct one.
+        for remapping in &self.inner {
+            // Check if the current file is executing inside the context's directory tree.
+            // This prevents a file in `/project_a/` from using a dependency meant for `/project_b/`
+            if !current_file.starts_with(&remapping.context_prefix) {
+                continue;
+            }
+
+            // Check if the alias matches what the user typed
+            if remapping.dependency_root_path == first_segment {
+                let mut resolved_path = remapping.target.clone();
+                resolved_path.extend(&parts[1..]);
+                return Ok(resolved_path);
+            }
+        }
+
+        // No matches found
+        Err(Error::UnknownLibrary(first_segment.to_string())).with_span(*use_decl.span())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::str::Identifier;
+
+    use super::*;
+
+    // --- TEST HELPERS ---
+
+    impl DependencyMap {
+        /// Inserts a dependency remapping without interacting with the physical file system.
+        pub fn test_insert_without_canonicalize(
+            &mut self,
+            context: &Path,
+            dependency_root_path: String,
+            path: &Path,
+        ) {
+            self.inner.push(Remapping {
+                context_prefix: context.to_path_buf(),
+                dependency_root_path,
+                target: path.to_path_buf(),
+            });
+            self.sort_mappings();
+        }
+    }
+
+    /// Helper to easily construct a `UseDecl` for path resolution tests.
+    fn create_dummy_use_decl(path_segments: &[&str]) -> UseDecl {
+        // Convert string slices into `Identifier` struct.
+        // If your macro generates a different constructor, just swap `From::from`
+        // with `Identifier::new(s)` or `Identifier(Arc::from(s))`!
+        let path: Vec<Identifier> = path_segments
+            .iter()
+            .map(|&s| Identifier::dummy(s))
+            .collect();
+
+        UseDecl::dummy_path(path)
+    }
+
+    // --- TESTS ---
+
+    #[test]
+    fn test_sorting_longest_prefix() {
+        let mut map = DependencyMap::new();
+
+        map.test_insert_without_canonicalize(
+            Path::new("/workspace"),
+            "math".to_string(),
+            Path::new("/lib/math_v1"),
+        );
+        map.test_insert_without_canonicalize(
+            Path::new("/workspace/project_a/nested"),
+            "math".to_string(),
+            Path::new("/lib/math_v3"),
+        );
+        map.test_insert_without_canonicalize(
+            Path::new("/workspace/project_a"),
+            "math".to_string(),
+            Path::new("/lib/math_v2"),
+        );
+
+        assert_eq!(
+            map.inner[0].context_prefix,
+            Path::new("/workspace/project_a/nested")
+        );
+        assert_eq!(
+            map.inner[1].context_prefix,
+            Path::new("/workspace/project_a")
+        );
+        assert_eq!(map.inner[2].context_prefix, Path::new("/workspace"));
+    }
+
+    #[test]
+    fn test_context_isolation() {
+        let mut map = DependencyMap::new();
+        map.test_insert_without_canonicalize(
+            Path::new("/project_a"),
+            "utils".to_string(),
+            Path::new("/libs/utils_a"),
+        );
+
+        let current_file = Path::new("/project_b/main.simf");
+        let use_decl = create_dummy_use_decl(&["utils"]);
+
+        let result = map.resolve_path(current_file, &use_decl);
+
+        assert!(result.is_err());
+        assert!(matches!(
+            result.unwrap_err().error(),
+            Error::UnknownLibrary(..)
+        ));
+    }
+
+    #[test]
+    fn test_resolve_longest_prefix_match() {
+        let mut map = DependencyMap::new();
+
+        map.test_insert_without_canonicalize(
+            Path::new("/workspace"),
+            "math".to_string(),
+            Path::new("/libs/global_math"),
+        );
+        map.test_insert_without_canonicalize(
+            Path::new("/workspace/frontend"),
+            "math".to_string(),
+            Path::new("/libs/frontend_math"),
+        );
+
+        // 1. Frontend file -> should resolve to frontend_math
+        let frontend_file = Path::new("/workspace/frontend/src/main.simf");
+        let use_decl = create_dummy_use_decl(&["math", "vector"]);
+
+        let resolved_frontend = map.resolve_path(frontend_file, &use_decl).unwrap();
+        assert_eq!(resolved_frontend, Path::new("/libs/frontend_math/vector"));
+
+        // 2. Backend file -> should bypass frontend and hit global_math
+        let backend_file = Path::new("/workspace/backend/src/main.simf");
+
+        let resolved_backend = map.resolve_path(backend_file, &use_decl).unwrap();
+        assert_eq!(resolved_backend, Path::new("/libs/global_math/vector"));
+    }
+
+    #[test]
+    fn test_resolve_subpath_extension() {
+        let mut map = DependencyMap::new();
+        map.test_insert_without_canonicalize(
+            Path::new("/app"),
+            "core".to_string(),
+            Path::new("/vendor/core_lib"),
+        );
+
+        let current_file = Path::new("/app/main.simf");
+        let use_decl = create_dummy_use_decl(&["core", "network", "http"]);
+
+        let resolved = map.resolve_path(current_file, &use_decl).unwrap();
+        assert_eq!(resolved, Path::new("/vendor/core_lib/network/http"));
+    }
+}

src/str.rs

@@ -293,3 +293,14 @@ impl ModuleName {
 }
 
 wrapped_string!(ModuleName, "module name");
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    impl Identifier {
+        pub fn dummy(name: &str) -> Self {
+            Self(std::sync::Arc::from(name))
+        }
+    }
+}