remove old code for extracting storage var getters

We decided to move away from creating separate storage vars based on function names. It's fragile and unreliable. However, some code for it was still left in warp, it's time to clean it up.
ifenjika · Dec 14, 2021 · 61baa5e · 61baa5e
1 parent 2e410be
commit 61baa5e
Show file tree

Hide file tree

Showing 5 changed files with 20 additions and 82 deletions.
diff --git a/tests/golden/ERC20.cairo b/tests/golden/ERC20.cairo
@@ -30,10 +30,6 @@ func sload{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}(ke
     return (value)
 end
 
-@storage_var
-func balances(arg0_low, arg0_high) -> (res : Uint256):
-end
-
 @storage_var
 func evm_storage(arg0_low, arg0_high) -> (res : Uint256):
 end
@@ -249,10 +245,15 @@ func abi_decode_address{exec_env : ExecutionEnvironment*, range_check_ptr}(dataE
     return (value0)
 end
 
-func getter_fun_balances{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}(
-        key : Uint256) -> (ret__warp_mangled : Uint256):
+func getter_fun_balances{
+        memory_dict : DictAccess*, msize, pedersen_ptr : HashBuiltin*, range_check_ptr,
+        syscall_ptr : felt*}(key : Uint256) -> (ret__warp_mangled : Uint256):
     alloc_locals
-    let (ret__warp_mangled) = balances.read(key.low, key.high)
+    uint256_mstore(offset=Uint256(low=0, high=0), value=key)
+    uint256_mstore(offset=Uint256(low=32, high=0), value=Uint256(low=0, high=0))
+    let (__warp_subexpr_0 : Uint256) = uint256_pedersen(
+        Uint256(low=0, high=0), Uint256(low=64, high=0))
+    let (ret__warp_mangled : Uint256) = sload(__warp_subexpr_0)
     return (ret__warp_mangled)
 end
 

diff --git a/tests/golden/ERC20_storage.cairo b/tests/golden/ERC20_storage.cairo
@@ -30,10 +30,6 @@ func sstore{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}(
     return ()
 end
 
-@storage_var
-func balanceOf(arg0_low, arg0_high) -> (res : Uint256):
-end
-
 @storage_var
 func evm_storage(arg0_low, arg0_high) -> (res : Uint256):
 end
@@ -310,10 +306,15 @@ func abi_encode_bool{memory_dict : DictAccess*, msize, range_check_ptr}(
     return (tail)
 end
 
-func getter_fun_balanceOf{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}(
-        key : Uint256) -> (ret__warp_mangled : Uint256):
+func getter_fun_balanceOf{
+        memory_dict : DictAccess*, msize, pedersen_ptr : HashBuiltin*, range_check_ptr,
+        syscall_ptr : felt*}(key : Uint256) -> (ret__warp_mangled : Uint256):
     alloc_locals
-    let (ret__warp_mangled) = balanceOf.read(key.low, key.high)
+    uint256_mstore(offset=Uint256(low=0, high=0), value=key)
+    uint256_mstore(offset=Uint256(low=32, high=0), value=Uint256(low=2, high=0))
+    let (__warp_subexpr_0 : Uint256) = uint256_pedersen(
+        Uint256(low=0, high=0), Uint256(low=64, high=0))
+    let (ret__warp_mangled : Uint256) = sload(__warp_subexpr_0)
     return (ret__warp_mangled)
 end
 

diff --git a/warp/yul/RevertNormalizer.py b/warp/yul/RevertNormalizer.py
@@ -7,7 +7,6 @@
 import yul.yul_ast as ast
 from yul.AstMapper import AstMapper
 from yul.BuiltinHandler import BuiltinHandler
-from yul.storage_access import extract_var_from_getter, extract_var_from_setter
 from yul.top_sort import top_sort_ast
 
 REVERT = ast.FunctionCall(

diff --git a/warp/yul/ToCairoVisitor.py b/warp/yul/ToCairoVisitor.py
@@ -17,14 +17,7 @@
 )
 from yul.Imports import format_imports, merge_imports
 from yul.NameGenerator import NameGenerator
-from yul.storage_access import (
-    StorageVar,
-    extract_var_from_getter,
-    extract_var_from_setter,
-    generate_getter_body,
-    generate_setter_body,
-    generate_storage_var_declaration,
-)
+from yul.storage_access import generate_storage_var_declaration
 
 UINT128_BOUND = 2 ** 128
 
@@ -65,12 +58,11 @@ def __init__(
         self.last_function: Optional[ast.FunctionDefinition] = None
         self.last_used_implicits: tuple[str, ...] = ()
         self.function_to_implicits: dict[str, set[str]] = {}
-        self.storage_variables: set[StorageVar] = set()
         self.next_stmt_is_leave: bool = False
 
     def translate(self, node: ast.Node) -> str:
         main_part = self.print(node)
-        storage_vars = self.storage_variables | self.cairo_functions.storage_vars
+        storage_vars = self.cairo_functions.storage_vars
         storage_var_decls = [
             generate_storage_var_declaration(x) for x in sorted(storage_vars)
         ]
@@ -186,10 +178,7 @@ def visit_function_definition(self, node: ast.FunctionDefinition):
         self.last_function = node
         params_repr = ", ".join(self.print(x) for x in node.parameters)
         returns_repr = ", ".join(self.print(x) for x in node.return_variables)
-        body_repr = self._try_make_storage_accessor_body(node)
-        if not body_repr:
-            body_repr = self.print(node.body)
-
+        body_repr = self.print(node.body)
         implicits = sorted(self.function_to_implicits.setdefault(node.name, set()))
         implicits_decl = ""
         if implicits:
@@ -249,40 +238,6 @@ def _new_statement(self):
         finally:
             self.last_used_implicits = old
 
-    def _try_make_storage_accessor_body(
-        self, node: ast.FunctionDefinition
-    ) -> Optional[str]:
-        getter_var = extract_var_from_getter(node.name)
-        setter_var = extract_var_from_setter(node.name)
-        if not (getter_var or setter_var):
-            return None
-
-        self._add_implicits(node.name, "pedersen_ptr", "range_check_ptr", "syscall_ptr")
-        accessor_args = tuple(x.name for x in node.parameters)
-        if getter_var:
-            assert (
-                len(node.return_variables) == 1
-            ), "We don't support multivalued storage variables yet"
-            name = getter_var
-            arg_types = tuple(x.type for x in node.parameters)
-            res_type = node.return_variables[0].type
-            body = generate_getter_body(
-                getter_var, accessor_args, node.return_variables[0].name
-            )
-        else:
-            assert setter_var
-            assert (
-                node.parameters
-            ), "Storage variable setters must have at least one parameter (the value to set)"
-            name = setter_var
-            arg_types = tuple(x.type for x in node.parameters[:-1])
-            res_type = node.parameters[-1].type
-            body = generate_setter_body(setter_var, accessor_args)
-        self.storage_variables.add(
-            StorageVar(name=name, arg_types=arg_types, res_type=res_type)
-        )
-        return body
-
     def _add_implicits(self, fn_name: str, *implicits: str):
         self.function_to_implicits.setdefault(fn_name, set()).update(implicits)
 

diff --git a/warp/yul/storage_access.py b/warp/yul/storage_access.py
@@ -1,28 +1,10 @@
 from __future__ import annotations
 
-import re
 from dataclasses import dataclass
-from typing import Iterable, Optional
+from typing import Iterable
 
 from yul.WarpException import warp_assert
 
-GETTER_PATTERN = re.compile(r"getter_fun_(\S*)(_(\d+))?")
-SETTER_PATTERN = re.compile(r"setter_fun_(\S*)(_(\d+))?")
-
-
-def extract_var_from_getter(getter: str) -> Optional[str]:
-    match = re.fullmatch(GETTER_PATTERN, getter)
-    if not match:
-        return None
-    return match.group(1)
-
-
-def extract_var_from_setter(setter: str) -> Optional[str]:
-    match = re.fullmatch(SETTER_PATTERN, setter)
-    if not match:
-        return None
-    return match.group(1)
-
 
 @dataclass(frozen=True, order=True)
 class StorageVar: