Add tests for literals (#83)

* prep for tests * tests * lints * fix valid large negative test * fix literal tests/code * tiny lint * lint --------- Co-authored-by: brock elmore <[email protected]>
nascentxyz · Jul 10, 2024 · 44ec8f1 · 44ec8f1
1 parent 36c8878
commit 44ec8f1
Show file tree

Hide file tree

Showing 10 changed files with 932 additions and 93 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -29,7 +29,7 @@ debug = true
 
 [profile.dev]
 # opt-level = 1  # Enable some optimizations like tail call
-inline = true
+# inline = true
 
 [profile.bench]
 debug = true

diff --git a/crates/graph/src/nodes/concrete.rs b/crates/graph/src/nodes/concrete.rs
@@ -878,6 +878,29 @@ impl Concrete {
         }
     }
 
+    pub fn needed_size(&self) -> Option<u16> {
+        match self {
+            Concrete::Uint(_, val) => Some(((32 - (val.leading_zeros() / 8)) * 8).max(8) as u16),
+            Concrete::Int(_, val) => {
+                let unsigned = val.unsigned_abs();
+                Some(((32 - (unsigned.leading_zeros() / 8)) * 8).max(8) as u16)
+            }
+            _ => None,
+        }
+    }
+
+    pub fn fit_size(self) -> Self {
+        if let Some(needed) = self.needed_size() {
+            match self {
+                Concrete::Uint(_, val) => Concrete::Uint(needed, val),
+                Concrete::Int(_, val) => Concrete::Int(needed, val),
+                _ => self,
+            }
+        } else {
+            self
+        }
+    }
+
     /// If its `Concrete::Uint`, gets the value
     pub fn uint_val(&self) -> Option<U256> {
         match self {

diff --git a/crates/graph/src/range/solc_range.rs b/crates/graph/src/range/solc_range.rs
@@ -171,30 +171,12 @@ impl SolcRange {
             | c @ Concrete::Int(_, _)
             | c @ Concrete::Bool(_)
             | c @ Concrete::Address(_)
+            | c @ Concrete::String(_)
             | c @ Concrete::Bytes(_, _) => Some(SolcRange::new(
                 Elem::Concrete(RangeConcrete::new(c.clone(), Loc::Implicit)),
                 Elem::Concrete(RangeConcrete::new(c, Loc::Implicit)),
                 vec![],
             )),
-            Concrete::String(s) => {
-                let val = s
-                    .chars()
-                    .enumerate()
-                    .map(|(i, v)| {
-                        let idx = Elem::from(Concrete::from(U256::from(i)));
-                        let mut bytes = [0x00; 32];
-                        v.encode_utf8(&mut bytes[..]);
-                        let v = Elem::from(Concrete::Bytes(1, H256::from(bytes)));
-                        (idx, v)
-                    })
-                    .collect::<BTreeMap<_, _>>();
-                let r = Elem::ConcreteDyn(RangeDyn::new(
-                    Elem::from(Concrete::from(U256::from(s.len()))),
-                    val,
-                    Loc::Implicit,
-                ));
-                Some(SolcRange::new(r.clone(), r, vec![]))
-            }
             Concrete::DynBytes(b) => {
                 let val = b
                     .iter()

diff --git a/crates/graph/src/solvers/dl.rs b/crates/graph/src/solvers/dl.rs
@@ -570,10 +570,10 @@ impl DLSolver {
                 added_atoms.push((*dyn_elem).clone());
                 self.graph_map.insert((*dyn_elem).clone(), idx);
                 if let Some(dep) = dep {
-                    if !self.var_to_atom_idx.contains_key(&dep) {
+                    self.var_to_atom_idx.entry(dep).or_insert_with(|| {
                         added_deps.push(dep);
-                        self.var_to_atom_idx.insert(dep, idx);
-                    }
+                        idx
+                    });
                 }
                 idx
             };

diff --git a/crates/graph/src/var_type.rs b/crates/graph/src/var_type.rs
@@ -407,6 +407,7 @@ impl VarType {
     }
 
     pub fn range(&self, analyzer: &impl GraphBackend) -> Result<Option<SolcRange>, GraphError> {
+        println!("here: {:?}", self);
         match self {
             Self::User(_, Some(range)) => Ok(Some(range.clone())),
             Self::BuiltIn(_, Some(range)) => Ok(Some(range.clone())),

diff --git a/crates/pyrometer/src/graph_backend.rs b/crates/pyrometer/src/graph_backend.rs
@@ -572,10 +572,10 @@ pub fn arena_mermaid_node(
             format!("{indent}{}{{{{\"{}\"}}}}", idx.index(), arena_idx)
         }
         ArenaNode::ELEM(label) => {
-            format!("{indent}{}(\"{}\")", idx.index(), label.replace("\"", "'"))
+            format!("{indent}{}(\"{}\")", idx.index(), label.replace('"', "'"))
         }
         ArenaNode::CVAR(label) => {
-            format!("{indent}{}(\"{}\")", idx.index(), label.replace("\"", "'"))
+            format!("{indent}{}(\"{}\")", idx.index(), label.replace('"', "'"))
         }
     };
 

diff --git a/crates/solc-expressions/Cargo.toml b/crates/solc-expressions/Cargo.toml
@@ -23,3 +23,7 @@ tracing.workspace = true
 tracing-subscriber.workspace = true
 
 keccak-hash = "0.10.0"
+
+[dev-dependencies]
+pyrometer.workspace = true
+eyre = "0.6"
diff --git a/crates/solc-expressions/src/context_builder/expr.rs b/crates/solc-expressions/src/context_builder/expr.rs
@@ -81,13 +81,15 @@ pub trait ExpressionParser:
             HexNumberLiteral(loc, b, _unit) => self.hex_num_literal(ctx, *loc, b, false),
             HexLiteral(hexes) => self.hex_literals(ctx, hexes),
             RationalNumberLiteral(loc, integer, fraction, exp, unit) => {
-                self.rational_number_literal(arena, ctx, *loc, integer, fraction, exp, unit)
+                self.rational_number_literal(arena, ctx, *loc, integer, fraction, exp, unit, false)
             }
             Negate(_loc, expr) => match &**expr {
                 NumberLiteral(loc, int, exp, unit) => {
                     self.number_literal(ctx, *loc, int, exp, true, unit)
                 }
                 HexNumberLiteral(loc, b, _unit) => self.hex_num_literal(ctx, *loc, b, true),
+                RationalNumberLiteral(loc, integer, fraction, exp, unit) => self
+                    .rational_number_literal(arena, ctx, *loc, integer, fraction, exp, unit, true),
                 e => {
                     self.parse_ctx_expr(arena, e, ctx)?;
                     self.apply_to_edges(ctx, e.loc(), arena, &|analyzer, arena, ctx, loc| {