Method path_join

src/analysis/dfa.rs:618–670

Merge var storage of different paths when meet path join. The default merge operation is Union.

(
        &mut self,
        path_vec: Vec<usize>,
        merge_callback: F,
    )

    /// Merge var storage of different paths when meet path join. The default merge operation is Union.
    fn path_join<F: Fn(Vec<Symbol<T>>) -> Symbol<T>>(
        &mut self,
        path_vec: Vec<usize>,
        merge_callback: F,
    ) -> Result<()> {
        let mut merge_store: Storage<T> = HashMap::new();
        let mut changed_var: HashSet<&VarName> = HashSet::new();
        // find the same vars but have different symbols in paths.
        for path_id in &path_vec {
            let path_store = self
                .path_storage
                .get(path_id)
                .ok_or_else(|| eyre::eyre!("path id {path_id} not found."))?;
            for (var_name, sym) in path_store.iter() {
                if merge_store.contains_key(var_name) {
                    //log::trace!("The merge store already contains {var_name:?}");
                    let exist_sym = merge_store.get(var_name).unwrap();
                    // find different symbols
                    if !exist_sym.eq(sym) {
                        changed_var.insert(var_name);
                    }
                } else {
                    merge_store.insert(var_name.clone(), sym.clone());
                }
            }
        }
        // merge the symbols from different paths to a single symbol
        for var in changed_var {
            let mut wait_to_merge = vec![];
            for path_id in &path_vec {
                let path_store = self
                    .path_storage
                    .get(path_id)
                    .ok_or_else(|| eyre::eyre!("path id {path_id} not found."))?;
                if path_store.contains_key(var) {
                    let value = path_store.get(var).unwrap();
                    wait_to_merge.push(value.clone());
                }
            }
            log::trace!("merge symbol for var: {var:?}");
            let new_sym = (merge_callback)(wait_to_merge);
            merge_store.insert(var.clone(), new_sym);
        }

        for (_var, sym) in merge_store.iter_mut() {
            sym.get_data_mut().refine()?;
        }
        // create new path id.
        self.path_id = self.new_path_id();
        // initial the storage for the new path
        self.path_storage.insert(self.path_id, merge_store);
        Ok(())
    }
}

#[derive(Default)]