Method parse

parser/src/lib.rs:93–146

(&mut self, path: &str, content: &str)

    }

    pub fn parse(&mut self, path: &str, content: &str) -> Result<ParsedFile> {
        let lang = SupportedLanguage::from_path(path)
            .ok_or_else(|| anyhow!("unsupported language for file: {path}"))?;
        #[cfg(feature = "rust-support")]
        if lang == SupportedLanguage::Rust {
            return semantic_rust::parse_to_engine(path, content);
        }

        self.parser
            .set_language(&lang.grammar())
            .context("failed to set tree-sitter language")?;

        let cache_key = format!("{path}:{}", checksum(content));
        let tree = if let Some(cached) = self.cache.get(&cache_key) {
            cached
        } else {
            let parsed = self
                .parser
                .parse(content, None)
                .ok_or_else(|| anyhow!("failed to parse file: {path}"))?;
            self.cache.set(cache_key, parsed.clone());
            parsed
        };

        let root = tree.root_node();
        let mut symbols = Vec::new();
        let mut dependencies = Vec::new();
        let mut logic_nodes = Vec::new();
        let import_targets = collect_import_targets(root, content, path);
        collect_nodes(
            root,
            content,
            path,
            lang.name(),
            &mut symbols,
            &mut dependencies,
            &mut logic_nodes,
            &import_targets,
        );
        let (control_flow_edges, data_flow_edges, logic_clusters) =
            build_graph_artifacts(&logic_nodes, content);
        annotate_local_dependency_targets(path, &symbols, &mut dependencies);

        Ok(ParsedFile {
            file: path.to_string(),
            language: lang.name().to_string(),
            symbols,
            dependencies,
            logic_nodes,
            control_flow_edges,
            data_flow_edges,
            logic_clusters,
        })
    }
}

fn checksum(content: &str) -> String {