Moves from recursion parsing to stack parsing

Cargo.toml

@@ -11,7 +11,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 authors = ["Brock Elmore"]
 license = "MIT OR Apache-2.0"

crates/analyzers/src/bounds.rs

@@ -2,18 +2,29 @@ use crate::{FunctionVarsBoundAnalysis, LocSpan, LocStrSpan, ReportConfig, VarBou
 
 use graph::{
     elem::Elem,
-    nodes::{Concrete, ContextNode},
+    nodes::{Concrete, ContextNode, KilledKind},
     range_string::ToRangeString,
     GraphBackend, Range, RangeEval, SolcRange,
 };
 use shared::{RangeArena, StorageLocation};
 
 use ariadne::{Color, Fmt, Label, Span};
-use std::collections::{BTreeMap, BTreeSet};
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    fmt,
+};
 
 pub static MIN_COLOR: Color = Color::Fixed(111);
 pub static MAX_COLOR: Color = Color::Fixed(106);
 
+pub fn killed_kind_color(kind: &KilledKind) -> Color {
+    match kind {
+        KilledKind::Ended => Color::Green,
+        KilledKind::Unreachable => Color::Rgb(255, 121, 0),
+        _ => Color::Red,
+    }
+}
+
 #[derive(PartialEq, Eq, Clone)]
 pub struct AnalysisItem {
     pub init: bool,
@@ -159,9 +170,9 @@ impl RangePart {
 
     pub fn to_normal_string(&self) -> String {
         match self {
-            e @ RangePart::Equal(_) => format!(" == {}", e.to_string()),
-            e @ RangePart::Inclusion(..) => format!(" ∈ {}", e.to_string()),
-            e @ RangePart::Exclusion(_) => format!("&& ∉ {{{}}}", e.to_string()),
+            e @ RangePart::Equal(_) => format!(" == {}", e),
+            e @ RangePart::Inclusion(..) => format!(" ∈ {}", e),
+            e @ RangePart::Exclusion(_) => format!("&& ∉ {{{}}}", e),
         }
     }
 }
@@ -214,16 +225,11 @@ impl From<AnalysisItem> for Label<LocStrSpan> {
     }
 }
 
-impl ToString for StrippedAnalysisItem {
-    fn to_string(&self) -> String {
-        format!(
+impl fmt::Display for StrippedAnalysisItem {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
             "{}{}{}",
-            // match self.storage {
-            //     Some(StorageLocation::Memory(..)) => "Memory var ",
-            //     Some(StorageLocation::Storage(..)) => "Storage var ",
-            //     Some(StorageLocation::Calldata(..)) => "Calldata var ",
-            //     None => "",
-            // },
             self.name,
             self.parts
                 .iter()
@@ -239,12 +245,13 @@ impl ToString for StrippedAnalysisItem {
     }
 }
 
-impl ToString for RangePart {
-    fn to_string(&self) -> String {
+impl fmt::Display for RangePart {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            RangePart::Equal(inner) => inner.to_string(),
-            RangePart::Inclusion(min, max) => format!("[ {}, {} ]", min, max),
-            RangePart::Exclusion(inner) => format!(
+            RangePart::Equal(inner) => write!(f, "{}", inner),
+            RangePart::Inclusion(min, max) => write!(f, "[ {}, {} ]", min, max),
+            RangePart::Exclusion(inner) => write!(
+                f,
                 "{{{}}}",
                 inner
                     .iter()

crates/analyzers/src/func_analyzer/mod.rs

@@ -1,3 +1,4 @@
+use crate::bounds::killed_kind_color;
 use crate::{
     bounds::range_parts, LocStrSpan, ReportConfig, ReportDisplay, ReportKind, VarBoundAnalysis,
     VarBoundAnalyzer,
@@ -60,19 +61,6 @@ impl<'a> FunctionVarsBoundAnalysis {
                     .iter()
                     .map(|var| (var.as_controllable_name(analyzer, arena).unwrap(), var))
                     .collect::<BTreeMap<_, _>>();
-                // create the bound strings
-                // let atoms = ctx.dep_atoms(analyzer).unwrap();
-                // println!("had {} atoms", atoms.len());
-                // let mut handled_atom = vec![];
-                // let mut bounds_string: Vec<String> = vec![];
-                // atoms.iter().enumerate().for_each(|(i, atom)| {
-                //     let atom_str = atom.to_range_string(true, analyzer, arena).s;
-                //     if !handled_atom.contains(&atom_str) {
-                //         handled_atom.push(atom_str.clone());
-                //         bounds_string.push(format!("{}. {}", i + 1, atom_str))
-                //     }
-                // });
-                // let bounds_string = bounds_string.into_iter().collect::<Vec<_>>().join("\n");
 
                 let bounds_string = deps
                     .iter()
@@ -231,7 +219,7 @@ impl<'a> FunctionVarsBoundAnalysis {
                                         labels.push(
                                             Label::new(killed_loc.clone())
                                                 .with_message(kind.analysis_str())
-                                                .with_color(Color::Red)
+                                                .with_color(killed_kind_color(kind))
                                                 .with_priority(10),
                                         );
                                     }
@@ -247,8 +235,8 @@ impl<'a> FunctionVarsBoundAnalysis {
                     if !self_handled {
                         labels.push(
                             Label::new(killed_span.clone())
-                                .with_message(kind.analysis_str().fg(Color::Red))
-                                .with_color(Color::Red),
+                                .with_message(kind.analysis_str().fg(killed_kind_color(kind)))
+                                .with_color(killed_kind_color(kind)),
                         );
                     }
                 }
@@ -332,14 +320,14 @@ pub trait FunctionVarsBoundAnalyzer: VarBoundAnalyzer + Search + AnalyzerBackend
                 {
                     return None;
                 }
-                if !report_config.show_reverts
-                    && matches!(
-                        fork.underlying(self).unwrap().killed,
-                        Some((_, KilledKind::Revert))
-                    )
-                {
-                    return None;
-                }
+                // if !report_config.show_reverts
+                //     && matches!(
+                //         fork.underlying(self).unwrap().killed,
+                //         Some((_, KilledKind::Revert))
+                //     )
+                // {
+                //     return None;
+                // }
                 let mut parents = fork.parent_list(self).unwrap();
                 parents.reverse();
                 parents.push(*fork);

crates/analyzers/src/func_analyzer/report_display.rs

@@ -1,3 +1,4 @@
+use crate::bounds::killed_kind_color;
 use crate::{FunctionVarsBoundAnalysis, LocStrSpan, ReportDisplay, ReportKind};
 
 use graph::{elem::Elem, nodes::Concrete, GraphBackend};
@@ -74,8 +75,8 @@ impl<'a> ReportDisplay for CLIFunctionVarsBoundAnalysis<'a> {
         if let Some((killed_span, kind)) = &self.func_var_bound_analysis.ctx_killed {
             report = report.with_label(
                 Label::new(killed_span.clone())
-                    .with_message(kind.analysis_str().fg(Color::Red))
-                    .with_color(Color::Red),
+                    .with_message(kind.analysis_str().fg(killed_kind_color(kind)))
+                    .with_color(killed_kind_color(kind)),
             );
         }
 

crates/analyzers/src/var_analyzer/mod.rs

@@ -161,8 +161,9 @@ pub trait VarBoundAnalyzer: Search + AnalyzerBackend + Sized {
         let mut curr = cvar.first_version(self);
 
         let ctx = cvar.ctx(self);
-        let (func_span, func_body_span) =
-            if let Some(fn_call) = ctx.underlying(self).unwrap().fn_call {
+        let underlying = ctx.underlying(self).unwrap();
+        let (func_span, func_body_span) = if let Some(fn_call) = underlying.fn_call() {
+            if underlying.is_ext_fn_call() {
                 (
                     LocStrSpan::new(file_mapping, fn_call.underlying(self).unwrap().loc),
                     fn_call
@@ -172,18 +173,7 @@ pub trait VarBoundAnalyzer: Search + AnalyzerBackend + Sized {
                         .as_ref()
                         .map(|body| LocStrSpan::new(file_mapping, body.loc())),
                 )
-            } else if let Some(ext_fn_call) = ctx.underlying(self).unwrap().ext_fn_call {
-                (
-                    LocStrSpan::new(file_mapping, ext_fn_call.underlying(self).unwrap().loc),
-                    ext_fn_call
-                        .underlying(self)
-                        .unwrap()
-                        .body
-                        .as_ref()
-                        .map(|body| LocStrSpan::new(file_mapping, body.loc())),
-                )
             } else {
-                let fn_call = ctx.associated_fn(self).unwrap();
                 (
                     LocStrSpan::new(file_mapping, fn_call.underlying(self).unwrap().loc),
                     fn_call
@@ -193,7 +183,19 @@ pub trait VarBoundAnalyzer: Search + AnalyzerBackend + Sized {
                         .as_ref()
                         .map(|body| LocStrSpan::new(file_mapping, body.loc())),
                 )
-            };
+            }
+        } else {
+            let fn_call = ctx.associated_fn(self).unwrap();
+            (
+                LocStrSpan::new(file_mapping, fn_call.underlying(self).unwrap().loc),
+                fn_call
+                    .underlying(self)
+                    .unwrap()
+                    .body
+                    .as_ref()
+                    .map(|body| LocStrSpan::new(file_mapping, body.loc())),
+            )
+        };
 
         let mut ba: VarBoundAnalysis = if let Some(inherited) = inherited {
             let mut new_ba = inherited.clone();

crates/analyzers/src/var_analyzer/report_display.rs

@@ -1,3 +1,4 @@
+use crate::bounds::killed_kind_color;
 use crate::{
     bounds::{range_parts, AnalysisItem},
     LocStrSpan, ReportDisplay, ReportKind, VarBoundAnalysis,
@@ -84,8 +85,8 @@ impl ReportDisplay for VarBoundAnalysis {
         if let Some((killed_span, kind)) = &self.ctx_killed {
             report = report.with_label(
                 Label::new(killed_span.clone())
-                    .with_message(kind.analysis_str().fg(Color::Red))
-                    .with_color(Color::Red),
+                    .with_message(kind.analysis_str().fg(killed_kind_color(kind)))
+                    .with_color(killed_kind_color(kind)),
             );
         }
 

crates/cli/src/main.rs

@@ -110,6 +110,9 @@ struct Args {
 
     #[clap(long)]
     pub minimize_debug: Option<String>,
+
+    #[clap(long, default_value = "false")]
+    pub debug_stack: bool,
 }
 
 pub fn subscriber() {
@@ -243,6 +246,7 @@ fn main() {
         root: Root::RemappingsDirectory(env::current_dir().unwrap()),
         debug_panic: args.debug_panic || args.minimize_debug.is_some(),
         minimize_debug: args.minimize_debug,
+        debug_stack: args.debug_stack,
         ..Default::default()
     };
 
@@ -300,7 +304,6 @@ fn main() {
 
     println!("DONE ANALYZING IN: {parse_time}ms. Writing to cli...");
 
-    // println!("Arena: {:#?}", analyzer.range_arena);
     if unsafe { USE_DEBUG_SITE } {
         use pyrometer::graph_backend::mermaid_str;
         use pyrometer::graph_backend::post_to_site_arena;
@@ -324,7 +327,6 @@ fn main() {
     if args.stats {
         println!("{}", analyzer.stats(t_end, arena));
     }
-    // println!("Arena: {:#?}", analyzer.range_arena);
 
     // use self.sources to fill a BTreeMap with the file_no and SourcePath.path_to_solidity_file
     let mut file_mapping: BTreeMap<usize, String> = BTreeMap::new();
@@ -366,20 +368,10 @@ fn main() {
         analyzer.open_mermaid(arena);
     }
 
-    // println!("{}", analyzer.range_arena.ranges.iter().map(|i| {
-    //     let j = i.borrow();
-    //     let (min_cached, max_cached) = j.is_min_max_cached(&analyzer);
-    //     format!("\t{j}, is cached: {min_cached}, {max_cached}\n")
-    // }).collect::<Vec<_>>().join(""));
-    // println!("{}", analyzer.range_arena.map.iter().map(|(k, v)| {
-    //     format!("\t{}: {}\n", k, v)
-    // }).collect::<Vec<_>>().join(""));
-
     if args.debug {
         return;
     }
 
-    // println!("getting contracts");
     let all_contracts = analyzer
         .search_children(entry, &Edge::Contract)
         .into_iter()
@@ -431,7 +423,10 @@ fn main() {
     // } else {
     let _t1 = std::time::Instant::now();
     if args.contracts.is_empty() {
-        let funcs = analyzer.search_children(entry, &Edge::Func);
+        let mut funcs = analyzer.search_children(entry, &Edge::Func);
+        funcs.extend(analyzer.search_children(entry, &Edge::FallbackFunc));
+        funcs.extend(analyzer.search_children(entry, &Edge::Constructor));
+        funcs.extend(analyzer.search_children(entry, &Edge::ReceiveFunc));
         for func in funcs.into_iter() {
             if !args.funcs.is_empty() {
                 if args.funcs.iter().any(|analyze_for| {