fix: merge conflict resolutions

crates/cli/src/main.rs

@@ -6,7 +6,7 @@ use graph::{
 };
 use pyrometer::{Analyzer, Root, SourcePath};
 use reqwest::Client;
-use shared::Search;
+use shared::{post_to_site, Search};
 use shared::{GraphDot, USE_DEBUG_SITE};
 
 use ariadne::sources;
@@ -235,27 +235,7 @@ fn main() {
         },
     };
 
-    if args.debug_site {
-        unsafe {
-            USE_DEBUG_SITE = true;
-        }
-
-        let rt = Runtime::new().unwrap();
-        rt.block_on(async {
-            let client = Client::new();
-            let res = client
-                .post("http://127.0.0.1:8545/clear")
-                .send()
-                .await
-                .expect("Failed to send request");
 
-            if res.status().is_success() {
-                trace!("Successfully cleared history of site");
-            } else {
-                error!("Failed to clear history of site: {:?}", res.status());
-            }
-        });
-    }
 
     let mut analyzer = Analyzer {
         max_depth: args.max_stack_depth,
@@ -288,6 +268,30 @@ fn main() {
 
     let mut arena_base = Default::default();
     let arena = &mut arena_base;
+
+    if args.debug_site {
+        unsafe {
+            USE_DEBUG_SITE = true;
+        }
+
+        let rt = Runtime::new().unwrap();
+        rt.block_on(async {
+            let client = Client::new();
+            let res = client
+                .post("http://127.0.0.1:8545/clear")
+                .send()
+                .await
+                .expect("Failed to send request");
+
+            if res.status().is_success() {
+                trace!("Successfully cleared history of site");
+            } else {
+                error!("Failed to clear history of site: {:?}", res.status());
+            }
+        });
+        post_to_site(&analyzer, arena);
+    }
+
     let t0 = std::time::Instant::now();
     let maybe_entry = analyzer.parse(arena, &sol, &current_path, true);
     let t_end = t0.elapsed();
@@ -297,20 +301,23 @@ fn main() {
 
     // println!("Arena: {:#?}", analyzer.range_arena);
     if unsafe { USE_DEBUG_SITE } {
-        use shared::GraphLike;
         use pyrometer::graph_backend::mermaid_str;
         use pyrometer::graph_backend::post_to_site_arena;
         use pyrometer::graph_backend::Elems;
-        match Elems::try_from(analyzer.range_arena()) {
+        let elems = Elems::try_from(&*arena);
+        match elems {
             Ok(elems) => {
-                let elems_graph = elems.to_graph(&analyzer);
+                let elems_graph = elems.to_graph(&analyzer, arena);
                 let elems_graph_mermaid_str = mermaid_str(&elems_graph);
                 post_to_site_arena(elems_graph_mermaid_str);
             }
             Err(e) => {
                 eprintln!("Can't post arena, error creating Elems: {:?}", e);
             }
         };
+
+        // post the graph to the site
+        post_to_site(&analyzer, arena);
     }
 
     if args.stats {

crates/graph/src/graph_elements.rs

@@ -402,9 +402,7 @@ pub enum ContextEdge {
 }
 
 #[derive(Default)]
-pub(crate) struct DummyGraph {
-    pub range_arena: RangeArena<Elem<Concrete>>,
-}
+pub(crate) struct DummyGraph {}
 
 impl GraphLike for DummyGraph {
     type Node = Node;
@@ -417,12 +415,44 @@ impl GraphLike for DummyGraph {
     fn graph(&self) -> &Graph<Node, Edge, Directed, usize> {
         panic!("Dummy Graph")
     }
-    fn range_arena(&self) -> &RangeArena<Elem<Concrete>> {
-        &self.range_arena
-    }
-    fn range_arena_mut(&mut self) -> &mut RangeArena<Elem<Concrete>> {
-        &mut self.range_arena
-    }
 }
 
 impl GraphBackend for DummyGraph {}
+impl GraphDot for DummyGraph {
+    type T = Elem<Concrete>;
+
+    fn dot_str(&self, _arena: &mut RangeArena<<Self as GraphDot>::T>) -> String {
+        // Provide a basic implementation or a placeholder
+        "digraph DummyGraph {}".to_string()
+    }
+
+    fn cluster_str(
+        &self,
+        _arena: &mut RangeArena<Self::T>,
+        _node: NodeIdx,
+        _cluster_num: &mut usize,
+        _is_killed: bool,
+        _handled_nodes: std::sync::Arc<std::sync::Mutex<std::collections::BTreeSet<NodeIdx>>>,
+        _handled_edges: std::sync::Arc<std::sync::Mutex<std::collections::BTreeSet<petgraph::prelude::EdgeIndex<usize>>>>,
+        _depth: usize,
+        _as_mermaid: bool,
+    ) -> Option<String>
+    where
+        Self: std::marker::Sized {
+        todo!()
+    }
+
+    fn dot_str_no_tmps(&self, _arena: &mut RangeArena<Self::T>) -> String
+    where
+        Self: std::marker::Sized,
+    {
+        todo!()
+    }
+
+    fn mermaid_str(&self, _arena: &mut RangeArena<Self::T>) -> String
+    where
+        Self: std::marker::Sized,
+    {
+        todo!()
+    }
+}

crates/pyrometer/src/analyzer_backend.rs

@@ -1,5 +1,4 @@
 use crate::Analyzer;
-use shared::GraphDot;
 use graph::{
     elem::Elem,
     nodes::{
@@ -18,7 +17,7 @@ use solang_parser::{
     pt::{Expression, Loc},
 };
 
-use std::{collections::BTreeMap, path::PathBuf};
+use std::collections::BTreeMap;
 
 impl AnalyzerBackend for Analyzer {
     fn add_concrete_var(