fix: wire up load storage

Signed-off-by: salaheldinsoliman <salaheldin_sameh@aucegypt.edu>

Author: salaheldinsoliman

fmt/src/formatter.rs

@@ -20,7 +20,7 @@ use crate::{
 };
 use alloy_primitives::Address;
 use itertools::{Either, Itertools};
-use solang_parser::pt::{PragmaDirective, VersionComparator};
+use solang_parser::pt::{PragmaDirective, StorageType, VersionComparator};
 use std::{fmt::Write, str::FromStr};
 use thiserror::Error;
 
@@ -3333,6 +3333,13 @@ impl<'a, W: Write> Visitor for Formatter<'a, W> {
                 self.visit_list("", idents, Some(loc.start()), Some(loc.end()), false)?;
                 None
             }
+            VariableAttribute::StorageType(s) => {
+                match s {
+                    StorageType::Instance(_) => Some("instance".to_string()),
+                    StorageType::Temporary(_) => Some("temporary".to_string()),
+                    StorageType::Persistent(_) => Some("persistent".to_string()),
+                }
+            }
         };
         if let Some(token) = token {
             let loc = attribute.loc();

fmt/src/solang_ext/ast_eq.rs

@@ -75,6 +75,18 @@ impl AstEq for VariableDefinition {
     }
 }
 
+impl AstEq for StorageType {
+    fn ast_eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (StorageType::Instance(_), StorageType::Instance(_)) => true,
+            (StorageType::Persistent(_), StorageType::Persistent(_)) => true,
+            (StorageType::Temporary(_), StorageType::Temporary(_)) => true,
+            _ => false,
+            
+        }
+    }
+}
+
 impl AstEq for FunctionDefinition {
     fn ast_eq(&self, other: &Self) -> bool {
         // attributes
@@ -726,5 +738,6 @@ derive_ast_eq! { enum VariableAttribute {
     Constant(loc),
     Immutable(loc),
     Override(loc, idents),
+    StorageType(s)
     _
 }}

solang-parser/src/helpers/fmt.rs

@@ -4,7 +4,7 @@
 //!
 //! [ref]: https://docs.soliditylang.org/en/latest/style-guide.html
 
-use crate::pt;
+use crate::pt::{self, StorageType};
 use std::{
     borrow::Cow,
     fmt::{Display, Formatter, Result, Write},
@@ -1169,6 +1169,13 @@ impl Display for pt::VariableAttribute {
                 }
                 Ok(())
             }
+            Self::StorageType(storage) => {
+                match storage {
+                    StorageType::Instance(_) => f.write_str("instance"),
+                    StorageType::Temporary(_) => f.write_str("temporary"),
+                    StorageType::Persistent(_) => f.write_str("persistent"),
+                }
+            }
         }
     }
 }

solang-parser/src/helpers/loc.rs

@@ -28,6 +28,14 @@ impl OptionalCodeLocation for pt::Visibility {
     }
 }
 
+impl OptionalCodeLocation for pt::StorageType {
+    fn loc_opt(&self) -> Option<Loc> {
+        match self {
+            Self::Persistent(l) | Self::Temporary(l) | Self::Instance(l) => *l,
+        }
+    }
+}
+
 impl OptionalCodeLocation for pt::SourceUnit {
     #[inline]
     fn loc_opt(&self) -> Option<Loc> {
@@ -431,6 +439,7 @@ impl_for_enums! {
 
     pt::VariableAttribute: match self {
         Self::Visibility(ref l, ..) => l.loc_opt().unwrap_or_default(),
+        Self::StorageType(ref l, ..) => l.loc_opt().unwrap_or_default(),
         Self::Constant(l, ..)
         | Self::Immutable(l, ..)
         | Self::Override(l, ..) => l,

solang-parser/src/lexer.rs

@@ -179,6 +179,11 @@ pub enum Token<'input> {
     Default,
     YulArrow,
 
+    // Storage types for Soroban
+    Persistent,
+    Temporary,
+    Instance,
+
     Annotation(&'input str),
 }
 
@@ -316,6 +321,9 @@ impl<'input> fmt::Display for Token<'input> {
             Token::Default => write!(f, "default"),
             Token::YulArrow => write!(f, "->"),
             Token::Annotation(name) => write!(f, "@{name}"),
+            Token::Persistent => write!(f, "persistent"),
+            Token::Temporary => write!(f, "temporary"),
+            Token::Instance => write!(f, "instance"),
         }
     }
 }
@@ -553,6 +561,9 @@ static KEYWORDS: phf::Map<&'static str, Token> = phf_map! {
     "unchecked" => Token::Unchecked,
     "assembly" => Token::Assembly,
     "let" => Token::Let,
+    "persistent" => Token::Persistent,
+    "temporary" => Token::Temporary,
+    "instance" => Token::Instance,
 };
 
 impl<'input> Lexer<'input> {

solang-parser/src/pt.rs

@@ -955,6 +955,24 @@ pub enum VariableAttribute {
 
     /// `ovveride(<1>,*)`
     Override(Loc, Vec<IdentifierPath>),
+
+    /// Storage type.
+    StorageType(StorageType),
+}
+
+/// Soroban storage types.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "pt-serde", derive(Serialize, Deserialize))]
+#[repr(u8)] // for cmp; order of variants is important
+pub enum StorageType {
+    /// `persistent`
+    Persistent(Option<Loc>),
+
+    /// `Instance`
+    Instance(Option<Loc>),
+
+    /// `Temporary`
+    Temporary(Option<Loc>),
 }
 
 /// A variable definition.

solang-parser/src/solidity.lalrpop

@@ -359,8 +359,15 @@ Visibility: Visibility = {
     <l:@L> "private" <r:@R> => Visibility::Private(Some(Loc::File(file_no, l, r))),
 }
 
+StorageType: StorageType = {
+    <l:@L> "persistent" <r:@R> => StorageType::Persistent(Some(Loc::File(file_no, l, r))),
+    <l:@R> "temporary" <r:@R> => StorageType::Temporary(Some(Loc::File(file_no, l, r))),
+    <l:@R> "instance" <r:@R> => StorageType::Instance(Some(Loc::File(file_no, l, r))),
+}
+
 VariableAttribute: VariableAttribute = {
     Visibility => VariableAttribute::Visibility(<>),
+    StorageType => VariableAttribute::StorageType(<>),
     <l:@L> "constant" <r:@R> => VariableAttribute::Constant(Loc::File(file_no, l, r)),
     <l:@L> "immutable" <r:@R> => VariableAttribute::Immutable(Loc::File(file_no, l, r)),
     <l:@L> "override" <r:@R> => VariableAttribute::Override(Loc::File(file_no, l, r), Vec::new()),
@@ -1312,5 +1319,8 @@ extern {
         "switch" => Token::Switch,
         "case" => Token::Case,
         "default" => Token::Default,
+        "persistent" => Token::Persistent,
+        "temporary" => Token::Temporary,
+        "instance" => Token::Instance,
     }
 }

solang-parser/src/tests.rs

@@ -61,6 +61,22 @@ contract 9c {
     }
 }
 
+#[test]
+fn parse_storage_type() {
+    let src = r#"contract counter {
+    uint64  instance count = 1;
+
+    function decrement() public returns (uint64){
+        //count -= 1;
+        return count;
+    }
+}"#;
+
+    let res = crate::parse(src, 0);
+
+    println!("{:?}", res);
+}
+
 #[test]
 fn parse_test() {
     let src = r#"/// @title Foo

src/codegen/cfg.rs

@@ -70,6 +70,7 @@ pub enum Instr {
         res: usize,
         ty: Type,
         storage: Expression,
+        storage_type: Option<pt::StorageType>,
     },
     /// Clear storage at slot for ty (might span multiple slots)
     ClearStorage { ty: Type, storage: Expression },
@@ -78,6 +79,7 @@ pub enum Instr {
         ty: Type,
         value: Expression,
         storage: Expression,
+        storage_type: Option<pt::StorageType>,
     },
     /// In storage slot, set the value at the offset
     SetStorageBytes {
@@ -1027,7 +1029,7 @@ impl ControlFlowGraph {
                 true_block,
                 false_block,
             ),
-            Instr::LoadStorage { ty, res, storage } => format!(
+            Instr::LoadStorage { ty, res, storage, .. } => format!(
                 "%{} = load storage slot({}) ty:{}",
                 self.vars[res].id.name,
                 self.expr_to_string(contract, ns, storage),
@@ -1038,7 +1040,7 @@ impl ControlFlowGraph {
                 self.expr_to_string(contract, ns, storage),
                 ty.to_string(ns),
             ),
-            Instr::SetStorage { ty, value, storage } => format!(
+            Instr::SetStorage { ty, value, storage, .. } => format!(
                 "store storage slot({}) ty:{} = {}",
                 self.expr_to_string(contract, ns, storage),
                 ty.to_string(ns),

src/codegen/constant_folding.rs

@@ -129,7 +129,12 @@ pub fn constant_folding(cfg: &mut ControlFlowGraph, dry_run: bool, ns: &mut Name
                         };
                     }
                 }
-                Instr::SetStorage { ty, storage, value } => {
+                Instr::SetStorage {
+                    ty,
+                    storage,
+                    value,
+                    storage_type,
+                } => {
                     let (storage, _) = expression(storage, Some(&vars), cfg, ns);
                     let (value, _) = expression(value, Some(&vars), cfg, ns);
 
@@ -138,17 +143,19 @@ pub fn constant_folding(cfg: &mut ControlFlowGraph, dry_run: bool, ns: &mut Name
                             ty: ty.clone(),
                             storage,
                             value,
+                            storage_type: storage_type.clone(),
                         };
                     }
                 }
-                Instr::LoadStorage { ty, storage, res } => {
+                Instr::LoadStorage { ty, storage, res, storage_type } => {
                     let (storage, _) = expression(storage, Some(&vars), cfg, ns);
 
                     if !dry_run {
                         cfg.blocks[block_no].instr[instr_no] = Instr::LoadStorage {
                             ty: ty.clone(),
                             storage,
                             res: *res,
+                            storage_type: storage_type.clone(),
                         };
                     }
                 }