Support different Soroban storage types

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 {
@@ -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,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(),
                         };
                     }
                 }

src/codegen/dispatch/solana.rs

@@ -491,6 +491,7 @@ fn check_magic(magic_value: u32, cfg: &mut ControlFlowGraph, vartab: &mut Vartab
                 ty: Type::Uint(32),
                 value: 0.into(),
             },
+            storage_type: None,
         },
     );
 

src/codegen/expression.rs

@@ -1302,6 +1302,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(
@@ -1314,6 +1329,7 @@ fn post_incdec(
                             },
                             ty: ty.clone(),
                             storage: dest,
+                            storage_type,
                         },
                     );
                 }
@@ -1395,6 +1411,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(
@@ -1425,6 +1458,7 @@ fn pre_incdec(
                             },
                             ty: ty.clone(),
                             storage: dest,
+                            storage_type
                         },
                     );
                 }
@@ -2676,6 +2710,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 {
@@ -2710,6 +2761,7 @@ pub fn assign_single(
                             },
                             ty: ty.deref_any().clone(),
                             storage: dest,
+                            storage_type
                         },
                     );
                 }

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(),
                 },
             );
         }

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,
         },
     );
 }