feat: soroban storage types

Signed-off-by: salaheldinsoliman <[email protected]>
hyperledger-solang · Aug 24, 2024 · dc8110c · dc8110c
1 parent 06798cd
commit dc8110c
Show file tree

Hide file tree

Showing 24 changed files with 224 additions and 14 deletions.
diff --git a/fmt/src/formatter.rs b/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();

diff --git a/fmt/src/solang_ext/ast_eq.rs b/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)
     _
 }}
diff --git a/solang-parser/src/helpers/fmt.rs b/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"),
+                }
+            }
         }
     }
 }

diff --git a/solang-parser/src/helpers/loc.rs b/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,

diff --git a/solang-parser/src/lexer.rs b/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> {

diff --git a/solang-parser/src/pt.rs b/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.

diff --git a/solang-parser/src/solidity.lalrpop b/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,
     }
 }
diff --git a/solang-parser/src/tests.rs b/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

diff --git a/src/codegen/cfg.rs b/src/codegen/cfg.rs
@@ -78,6 +78,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 {
@@ -1038,7 +1039,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),

diff --git a/src/codegen/constant_folding.rs b/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,6 +143,7 @@ pub fn constant_folding(cfg: &mut ControlFlowGraph, dry_run: bool, ns: &mut Name
                             ty: ty.clone(),
                             storage,
                             value,
+                            storage_type: storage_type.clone(),
                         };
                     }
                 }

diff --git a/src/codegen/expression.rs b/src/codegen/expression.rs
@@ -1286,6 +1286,21 @@ fn post_incdec(
                 },
             );
 
+            let mut storage_type = None;
+            if let ast::Expression::StorageVariable {
+                loc: _,
+                ty: _,
+                var_no,
+                contract_no,
+            } = var
+            {
+                let var = ns.contracts[*contract_no].variables.get(*var_no).unwrap();
+
+                storage_type = var.storage_type.clone();
+
+                println!("storage_type {:?}", var);
+            }
+
             match var.ty() {
                 Type::StorageRef(..) => {
                     cfg.add(
@@ -1298,6 +1313,7 @@ fn post_incdec(
                             },
                             ty: ty.clone(),
                             storage: dest,
+                            storage_type,
                         },
                     );
                 }
@@ -1379,6 +1395,23 @@ fn pre_incdec(
             expr,
         },
     );
+
+
+    let mut storage_type = None;
+            if let ast::Expression::StorageVariable {
+                loc: _,
+                ty: _,
+                var_no,
+                contract_no,
+            } = var
+            {
+                let var = ns.contracts[*contract_no].variables.get(*var_no).unwrap();
+
+                storage_type = var.storage_type.clone();
+
+                println!("storage_type {:?}", var);
+            }
+
     match var {
         ast::Expression::Variable { loc, var_no, .. } => {
             cfg.add(
@@ -1409,6 +1442,7 @@ fn pre_incdec(
                             },
                             ty: ty.clone(),
                             storage: dest,
+                            storage_type
                         },
                     );
                 }
@@ -2660,6 +2694,23 @@ pub fn assign_single(
                 },
             );
 
+
+
+            let mut storage_type = None;
+            if let ast::Expression::StorageVariable {
+                loc: _,
+                ty: _,
+                var_no,
+                contract_no,
+            } = left
+            {
+                let var = ns.contracts[*contract_no].variables.get(*var_no).unwrap();
+
+                storage_type = var.storage_type.clone();
+
+                println!("storage_type {:?}", var);
+            }
+
             match left_ty {
                 Type::StorageRef(..) if set_storage_bytes => {
                     if let Expression::Subscript {
@@ -2694,6 +2745,7 @@ pub fn assign_single(
                             },
                             ty: ty.deref_any().clone(),
                             storage: dest,
+                            storage_type
                         },
                     );
                 }

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
@@ -284,6 +284,7 @@ fn storage_initializer(contract_no: usize, ns: &mut Namespace, opt: &Options) ->
                     value,
                     ty: var.ty.clone(),
                     storage,
+                    storage_type: var.storage_type.clone(),
                 },
             );
         }

diff --git a/src/codegen/solana_deploy.rs b/src/codegen/solana_deploy.rs
@@ -639,6 +639,7 @@ pub(super) fn solana_deploy(
                 ty: Type::Uint(64),
                 value: BigInt::zero(),
             },
+            storage_type: None,
         },
     );
 
@@ -663,6 +664,7 @@ pub(super) fn solana_deploy(
                 ty: Type::Uint(64),
                 value: BigInt::from(12),
             },
+            storage_type: None,
         },
     );
 }
diff --git a/src/codegen/storage.rs b/src/codegen/storage.rs
@@ -149,6 +149,7 @@ pub fn storage_slots_array_push(
                     ty: slot_ty.clone(),
                     var_no: entry_pos,
                 },
+                storage_type: None,
             },
         );
     }
@@ -176,6 +177,7 @@ pub fn storage_slots_array_push(
             ty: slot_ty,
             value: new_length,
             storage: var_expr,
+            storage_type: None,
         },
     );
 
@@ -368,6 +370,7 @@ pub fn storage_slots_array_pop(
                 var_no: new_length,
             },
             storage: var_expr,
+            storage_type: None,
         },
     );
 

diff --git a/src/codegen/subexpression_elimination/instruction.rs b/src/codegen/subexpression_elimination/instruction.rs
@@ -278,10 +278,16 @@ impl<'a, 'b: 'a> AvailableExpressionSet<'a> {
                 storage: self.regenerate_expression(storage, ave, cst).1,
             },
 
-            Instr::SetStorage { ty, value, storage } => Instr::SetStorage {
+            Instr::SetStorage {
+                ty,
+                value,
+                storage,
+                storage_type,
+            } => Instr::SetStorage {
                 ty: ty.clone(),
                 value: self.regenerate_expression(value, ave, cst).1,
                 storage: self.regenerate_expression(storage, ave, cst).1,
+                storage_type: storage_type.clone(),
             },
 
             Instr::SetStorageBytes {