microcad_lang/resolve/

sources.rs

// Copyright © 2025-2026 The µcad authors <info@microcad.xyz>
// SPDX-License-Identifier: AGPL-3.0-or-later

//! Source file cache

use derive_more::Deref;
use microcad_lang_base::{
    GetSourceLocInfoByHash, HashId, ResourceLocation, SourceLocInfo, SrcReferrer,
};

use crate::{
    lower::{LowerErrorsWithSource, ir},
    resolve::*,
};
use std::{collections::HashMap, rc::Rc};

/// Register of loaded source files and their syntax trees.
///
/// Source file definitions ([`SourceFile`]) are stored in a vector (`Vec<Rc<SourceFile>>`)
/// and mapped by *hash*, *path* and *name* via index to this vector.
///
/// The *root model* (given at creation) will be stored but will only be accessible by hash and path
/// but not by it's qualified name.
#[derive(Deref)]
pub struct Sources {
    by_hash: HashMap<u64, usize>,
    by_path: HashMap<std::path::PathBuf, usize>,
    by_name: HashMap<ir::QualifiedName, usize>,

    //root source file.
    root: Rc<ir::Source>,

    /// External source files.
    #[deref]
    pub source_files: Vec<Rc<ir::Source>>,

    /// Search paths.
    search_paths: Vec<std::path::PathBuf>,
}

impl Sources {
    /// Create source cache
    ///
    /// Inserts the `root` file and loads all files from `search_paths`.
    pub fn load(
        root: Rc<ir::Source>,
        search_paths: Vec<std::path::PathBuf>,
    ) -> ResolveResult<Self> {
        let mut source_files = Vec::new();
        let mut by_name = HashMap::new();
        let mut by_hash = HashMap::new();
        let mut by_path = HashMap::new();

        by_hash.insert(root.source_hash(), 0);
        by_path.insert(root.filename(), 0);
        by_name.insert(root.name.clone(), 0);
        source_files.push(root.clone());

        // load all external source files into cache
        Externals::new(&search_paths)?.iter().try_for_each(
            |(name, path)| -> Result<(), LowerErrorsWithSource> {
                let (source_file, error) = ir::Source::load_with_name(path.clone(), name.clone());
                let index = source_files.len();
                by_hash.insert(source_file.source_hash(), index);
                by_path.insert(source_file.filename(), index);
                by_name.insert(name.clone(), index);
                source_files.push(source_file);
                match error {
                    Some(error) => Err(error),
                    None => Ok(()),
                }
            },
        )?;

        Ok(Self {
            root,
            source_files,
            by_hash,
            by_path,
            by_name,
            search_paths: search_paths
                .iter()
                .map(|path| {
                    path.canonicalize()
                        .unwrap_or_else(|_| panic!("valid path: {}", path.display()))
                })
                .collect(),
        })
    }

    /// Return root file.
    pub fn root(&self) -> Rc<ir::Source> {
        self.root.clone()
    }

    /// Insert a file to the sources.
    pub fn insert(&mut self, source_file: Rc<ir::Source>) {
        let hash = source_file.source_hash();
        let path = source_file.filename();
        let name = source_file.name.clone();

        // maybe overwrite existing
        let index = if let Some(index) = self.by_path.get(&path).copied() {
            self.by_hash.remove(&hash);
            self.by_name.remove(&name);
            self.by_path.remove(&path);
            if self.root.filename() == path {
                self.root = source_file.clone();
            }
            self.source_files[index] = source_file;

            index
        } else {
            self.source_files.push(source_file.clone());
            self.source_files.len() - 1
        };

        self.by_hash.insert(hash, index);
        self.by_path.insert(path, index);
        self.by_name.insert(name, index);
    }

    /// Return the qualified name of a file by it's path
    pub fn generate_name_from_path(
        &self,
        file_path: &std::path::Path,
    ) -> ResolveResult<ir::QualifiedName> {
        // check root file name
        if self.root.filename() == file_path {
            return Ok(self.root.id().into());
        }

        // check file names relative to search paths
        let path = if let Some(path) = self
            .search_paths
            .iter()
            .find_map(|path| file_path.strip_prefix(path).ok())
        {
            path.with_extension("")
        }
        // check file names relative to project root directory
        else if let Some(root_dir) = self.root_dir() {
            if let Ok(path) = file_path.strip_prefix(root_dir) {
                path.with_extension("")
            } else {
                return Err(ResolveError::InvalidPath(file_path.to_path_buf()));
            }
        } else {
            return Err(ResolveError::InvalidPath(file_path.to_path_buf()));
        };

        // Remove prefix in testing environment
        let path = if let Ok(path) = path.strip_prefix(".test") {
            path.to_path_buf()
        } else {
            path
        };

        // check if file is a mod file then it gets it"s name from the parent directory
        let path = if path
            .iter()
            .next_back()
            .map(|s| s.to_string_lossy().to_string())
            == Some("mod".into())
        {
            path.parent()
        } else {
            Some(path.as_path())
        };

        // get name from path which was found
        if let Some(path) = path {
            Ok(path
                .iter()
                .map(|name| ir::Identifier::no_ref(name.to_string_lossy().as_ref()))
                .collect())
        } else {
            Err(ResolveError::InvalidPath(file_path.to_path_buf()))
        }
    }

    /// Convenience function to get a source file by from a `SrcReferrer`.
    pub fn get_by_src_ref(&self, referrer: &impl SrcReferrer) -> ResolveResult<Rc<ir::Source>> {
        self.get_by_hash(referrer.src_ref().source_hash())
    }

    /// Return code at referrer.
    pub fn get_code(&self, referrer: &impl SrcReferrer) -> ResolveResult<String> {
        Ok(self
            .get_by_src_ref(referrer)?
            .get_code(&referrer.src_ref())
            .to_string())
    }

    fn name_from_index(&self, index: usize) -> Option<ir::QualifiedName> {
        self.by_name
            .iter()
            .find(|(_, i)| **i == index)
            .map(|(name, _)| name.clone())
    }

    /// Return search paths of this cache.
    pub fn search_paths(&self) -> &Vec<std::path::PathBuf> {
        &self.search_paths
    }

    fn root_dir(&self) -> Option<std::path::PathBuf> {
        self.root.filename().parent().map(|p| p.to_path_buf())
    }

    /// Load another source file into cache.
    pub fn load_mod_file(
        &mut self,
        parent_path: impl AsRef<std::path::Path>,
        id: &ir::Identifier,
    ) -> ResolveResult<Rc<ir::Source>> {
        log::trace!(
            "loading file: {:?} [{id}]",
            parent_path.as_ref().canonicalize().expect("invalid path")
        );
        let file_path = find_mod_file_by_id(parent_path, id)?;
        let name = self.generate_name_from_path(&file_path)?;
        let (source_file, error) = ir::Source::load_with_name(&file_path, name);
        self.insert(source_file.clone());
        match error {
            Some(error) => Err(error.into()),
            None => Ok(source_file),
        }
    }
}

/// Trait that can fetch for a file by it's hash value.
pub trait GetSourceByHash {
    /// Find a project file by it's hash value.
    fn get_by_hash(&self, hash: u64) -> ResolveResult<Rc<ir::Source>>;
}

impl GetSourceLocInfoByHash for Sources {
    fn get_source_loc_info_by_hash(&'_ self, hash: HashId) -> Option<SourceLocInfo<'_>> {
        self.by_hash
            .get(&hash)
            .map(|index| self.source_files[*index].source_loc_info())
    }
}

impl GetSourceByHash for Sources {
    /// Find a project file by it's hash value.
    fn get_by_hash(&self, hash: u64) -> ResolveResult<Rc<ir::Source>> {
        if let Some(index) = self.by_hash.get(&hash) {
            Ok(self.source_files[*index].clone())
        } else if hash == 0 {
            Err(ResolveError::NulHash)
        } else {
            Err(ResolveError::UnknownHash(hash))
        }
    }
}

impl std::fmt::Display for Sources {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        for (index, source_file) in self.source_files.iter().enumerate() {
            let filename = source_file
                .to_file_path()
                .map(|p| p.to_string_lossy().to_string())
                .unwrap_or("NO FILE".to_string());
            let name = self.name_from_index(index).unwrap_or_default();
            let hash = source_file.source_hash();
            writeln!(f, "[{index}] {name} {hash:#x} {filename}")?;
        }
        Ok(())
    }
}

impl std::fmt::Debug for Sources {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        for (index, source_file) in self.source_files.iter().enumerate() {
            let filename = source_file
                .to_file_path()
                .map(|p| p.to_string_lossy().to_string())
                .unwrap_or("NO FILE".to_string());
            let name = self.name_from_index(index).unwrap_or_default();
            let hash = source_file.source_hash();
            writeln!(f, "[{index}] {name:?} {hash:#x} {filename}")?;
        }
        Ok(())
    }
}