rename evaluate to fold

tests/functional/builtins/folding/test_abs.py

@@ -21,7 +21,7 @@ def foo(a: int256) -> int256:
 
     vyper_ast = vy_ast.parse_to_ast(f"abs({a})")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.DISPATCH_TABLE["abs"].evaluate(old_node)
+    new_node = vy_fn.DISPATCH_TABLE["abs"].fold(old_node)
 
     assert contract.foo(a) == new_node.value == abs(a)
 

tests/functional/builtins/folding/test_addmod_mulmod.py

@@ -24,6 +24,6 @@ def foo(a: uint256, b: uint256, c: uint256) -> uint256:
 
     vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({a}, {b}, {c})")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].fold(old_node)
 
     assert contract.foo(a, b, c) == new_node.value

tests/functional/builtins/folding/test_bitwise.py

@@ -28,7 +28,7 @@ def foo(a: uint256, b: uint256) -> uint256:
 
     vyper_ast = vy_ast.parse_to_ast(f"{a} {op} {b}")
     old_node = vyper_ast.body[0].value
-    new_node = old_node.evaluate()
+    new_node = old_node.fold()
 
     assert contract.foo(a, b) == new_node.value
 
@@ -49,7 +49,7 @@ def foo(a: uint256, b: uint256) -> uint256:
     old_node = vyper_ast.body[0].value
 
     try:
-        new_node = old_node.evaluate()
+        new_node = old_node.fold()
         # force bounds check, no-op because validate_numeric_bounds
         # already does this, but leave in for hygiene (in case
         # more types are added).
@@ -79,7 +79,7 @@ def foo(a: int256, b: uint256) -> int256:
     old_node = vyper_ast.body[0].value
 
     try:
-        new_node = old_node.evaluate()
+        new_node = old_node.fold()
         validate_expected_type(new_node, INT256_T)  # force bounds check
     # compile time behavior does not match runtime behavior.
     # compile-time will throw on OOB, runtime will wrap.
@@ -104,6 +104,6 @@ def foo(a: uint256) -> uint256:
 
     vyper_ast = vy_ast.parse_to_ast(f"~{value}")
     old_node = vyper_ast.body[0].value
-    new_node = old_node.evaluate()
+    new_node = old_node.fold()
 
     assert contract.foo(value) == new_node.value

tests/functional/builtins/folding/test_epsilon.py

@@ -15,6 +15,6 @@ def foo() -> {typ_name}:
 
     vyper_ast = vy_ast.parse_to_ast(f"epsilon({typ_name})")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.DISPATCH_TABLE["epsilon"].evaluate(old_node)
+    new_node = vy_fn.DISPATCH_TABLE["epsilon"].fold(old_node)
 
     assert contract.foo() == new_node.value

tests/functional/builtins/folding/test_floor_ceil.py

@@ -30,6 +30,6 @@ def foo(a: decimal) -> int256:
 
     vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({value})")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].fold(old_node)
 
     assert contract.foo(value) == new_node.value

tests/functional/builtins/folding/test_fold_as_wei_value.py

@@ -32,7 +32,7 @@ def foo(a: decimal) -> uint256:
 
     vyper_ast = vy_ast.parse_to_ast(f"as_wei_value({value:.10f}, '{denom}')")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.AsWeiValue().evaluate(old_node)
+    new_node = vy_fn.AsWeiValue().fold(old_node)
 
     assert contract.foo(value) == new_node.value
 
@@ -51,6 +51,6 @@ def foo(a: uint256) -> uint256:
 
     vyper_ast = vy_ast.parse_to_ast(f"as_wei_value({value}, '{denom}')")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.AsWeiValue().evaluate(old_node)
+    new_node = vy_fn.AsWeiValue().fold(old_node)
 
     assert contract.foo(value) == new_node.value

tests/functional/builtins/folding/test_keccak_sha.py

@@ -22,7 +22,7 @@ def foo(a: String[100]) -> bytes32:
 
     vyper_ast = vy_ast.parse_to_ast(f"{fn_name}('''{value}''')")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].fold(old_node)
 
     assert f"0x{contract.foo(value).hex()}" == new_node.value
 
@@ -41,7 +41,7 @@ def foo(a: Bytes[100]) -> bytes32:
 
     vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({value})")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].fold(old_node)
 
     assert f"0x{contract.foo(value).hex()}" == new_node.value
 
@@ -62,6 +62,6 @@ def foo(a: Bytes[100]) -> bytes32:
 
     vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({value})")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].fold(old_node)
 
     assert f"0x{contract.foo(value).hex()}" == new_node.value

tests/functional/builtins/folding/test_len.py

@@ -17,7 +17,7 @@ def foo(a: String[1024]) -> uint256:
 
     vyper_ast = vy_ast.parse_to_ast(f"len('{value}')")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.Len().evaluate(old_node)
+    new_node = vy_fn.Len().fold(old_node)
 
     assert contract.foo(value) == new_node.value
 
@@ -35,7 +35,7 @@ def foo(a: Bytes[1024]) -> uint256:
 
     vyper_ast = vy_ast.parse_to_ast(f"len(b'{value}')")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.Len().evaluate(old_node)
+    new_node = vy_fn.Len().fold(old_node)
 
     assert contract.foo(value.encode()) == new_node.value
 
@@ -53,6 +53,6 @@ def foo(a: Bytes[1024]) -> uint256:
 
     vyper_ast = vy_ast.parse_to_ast(f"len({value})")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.Len().evaluate(old_node)
+    new_node = vy_fn.Len().fold(old_node)
 
     assert contract.foo(value) == new_node.value

tests/functional/builtins/folding/test_min_max.py

@@ -31,7 +31,7 @@ def foo(a: decimal, b: decimal) -> decimal:
 
     vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({left}, {right})")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].fold(old_node)
 
     assert contract.foo(left, right) == new_node.value
 
@@ -50,7 +50,7 @@ def foo(a: int128, b: int128) -> int128:
 
     vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({left}, {right})")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].fold(old_node)
 
     assert contract.foo(left, right) == new_node.value
 
@@ -69,6 +69,6 @@ def foo(a: uint256, b: uint256) -> uint256:
 
     vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({left}, {right})")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].fold(old_node)
 
     assert contract.foo(left, right) == new_node.value

tests/functional/builtins/folding/test_powmod.py

@@ -21,6 +21,6 @@ def foo(a: uint256, b: uint256) -> uint256:
 
     vyper_ast = vy_ast.parse_to_ast(f"pow_mod256({a}, {b})")
     old_node = vyper_ast.body[0].value
-    new_node = vy_fn.PowMod256().evaluate(old_node)
+    new_node = vy_fn.PowMod256().fold(old_node)
 
     assert contract.foo(a, b) == new_node.value

tests/unit/ast/nodes/test_evaluate_binop_decimal.py → tests/unit/ast/nodes/test_fold_binop_decimal.py

@@ -31,7 +31,7 @@ def foo(a: decimal, b: decimal) -> decimal:
     vyper_ast = vy_ast.parse_to_ast(f"{left} {op} {right}")
     old_node = vyper_ast.body[0].value
     try:
-        new_node = old_node.evaluate()
+        new_node = old_node.fold()
         is_valid = True
     except ZeroDivisionException:
         is_valid = False
@@ -48,7 +48,7 @@ def test_binop_pow():
     old_node = vyper_ast.body[0].value
 
     with pytest.raises(TypeMismatch):
-        old_node.evaluate()
+        old_node.fold()
 
 
 @pytest.mark.fuzzing

tests/unit/ast/nodes/test_evaluate_binop_int.py → tests/unit/ast/nodes/test_fold_binop_int.py

@@ -27,7 +27,7 @@ def foo(a: int128, b: int128) -> int128:
     vyper_ast = vy_ast.parse_to_ast(f"{left} {op} {right}")
     old_node = vyper_ast.body[0].value
     try:
-        new_node = old_node.evaluate()
+        new_node = old_node.fold()
         is_valid = True
     except ZeroDivisionException:
         is_valid = False
@@ -56,7 +56,7 @@ def foo(a: uint256, b: uint256) -> uint256:
     vyper_ast = vy_ast.parse_to_ast(f"{left} {op} {right}")
     old_node = vyper_ast.body[0].value
     try:
-        new_node = old_node.evaluate()
+        new_node = old_node.fold()
         is_valid = new_node.value >= 0
     except ZeroDivisionException:
         is_valid = False
@@ -83,7 +83,7 @@ def foo(a: uint256, b: uint256) -> uint256:
 
     vyper_ast = vy_ast.parse_to_ast(f"{left} ** {right}")
     old_node = vyper_ast.body[0].value
-    new_node = old_node.evaluate()
+    new_node = old_node.fold()
 
     assert contract.foo(left, right) == new_node.value
 

tests/unit/ast/nodes/test_evaluate_boolop.py → tests/unit/ast/nodes/test_fold_boolop.py

@@ -26,7 +26,7 @@ def foo({input_value}) -> bool:
 
     vyper_ast = vy_ast.parse_to_ast(literal_op)
     old_node = vyper_ast.body[0].value
-    new_node = old_node.evaluate()
+    new_node = old_node.fold()
 
     assert contract.foo(*values) == new_node.value
 

tests/unit/ast/nodes/test_evaluate_compare.py → tests/unit/ast/nodes/test_fold_compare.py

@@ -21,7 +21,7 @@ def foo(a: int128, b: int128) -> bool:
 
     vyper_ast = vy_ast.parse_to_ast(f"{left} {op} {right}")
     old_node = vyper_ast.body[0].value
-    new_node = old_node.evaluate()
+    new_node = old_node.fold()
 
     assert contract.foo(left, right) == new_node.value
 
@@ -41,7 +41,7 @@ def foo(a: uint128, b: uint128) -> bool:
 
     vyper_ast = vy_ast.parse_to_ast(f"{left} {op} {right}")
     old_node = vyper_ast.body[0].value
-    new_node = old_node.evaluate()
+    new_node = old_node.fold()
 
     assert contract.foo(left, right) == new_node.value
 
@@ -65,7 +65,7 @@ def bar(a: int128) -> bool:
 
     vyper_ast = vy_ast.parse_to_ast(f"{left} in {right}")
     old_node = vyper_ast.body[0].value
-    new_node = old_node.evaluate()
+    new_node = old_node.fold()
 
     # check runtime == fully folded
     assert contract.foo(left, right) == new_node.value
@@ -94,7 +94,7 @@ def bar(a: int128) -> bool:
 
     vyper_ast = vy_ast.parse_to_ast(f"{left} not in {right}")
     old_node = vyper_ast.body[0].value
-    new_node = old_node.evaluate()
+    new_node = old_node.fold()
 
     # check runtime == fully folded
     assert contract.foo(left, right) == new_node.value
@@ -109,4 +109,4 @@ def test_compare_type_mismatch(op):
     vyper_ast = vy_ast.parse_to_ast(f"1 {op} 1.0")
     old_node = vyper_ast.body[0].value
     with pytest.raises(UnfoldableNode):
-        old_node.evaluate()
+        old_node.fold()

tests/unit/ast/nodes/test_evaluate_subscript.py → tests/unit/ast/nodes/test_fold_subscript.py

@@ -21,6 +21,6 @@ def foo(array: int128[10], idx: uint256) -> int128:
 
     vyper_ast = vy_ast.parse_to_ast(f"{array}[{idx}]")
     old_node = vyper_ast.body[0].value
-    new_node = old_node.evaluate()
+    new_node = old_node.fold()
 
     assert contract.foo(array, idx) == new_node.value

tests/unit/ast/nodes/test_evaluate_unaryop.py → tests/unit/ast/nodes/test_fold_unaryop.py

@@ -14,7 +14,7 @@ def foo(a: bool) -> bool:
 
     vyper_ast = vy_ast.parse_to_ast(f"not {bool_cond}")
     old_node = vyper_ast.body[0].value
-    new_node = old_node.evaluate()
+    new_node = old_node.fold()
 
     assert contract.foo(bool_cond) == new_node.value
 

vyper/ast/README.md

@@ -82,8 +82,7 @@ folding include:
 
 The process of literal folding includes:
 
-1. Foldable node classes are evaluated via their `evaluate` method, which attempts
-to create a new `Constant` from the content of the given node.
+1. Foldable node classes are evaluated via their `fold` method, which attempts to create a new `Constant` from the content of the given node.
 2. Replacement nodes are generated using the `from_node` class method within the new
 node class.
 3. The modification of the tree is handled by `Module.replace_in_tree`, which locates

vyper/ast/folding.py

@@ -44,7 +44,7 @@ def replace_literal_ops(vyper_module: vy_ast.Module) -> int:
     node_types = (vy_ast.BoolOp, vy_ast.BinOp, vy_ast.UnaryOp, vy_ast.Compare)
     for node in vyper_module.get_descendants(node_types, reverse=True):
         try:
-            new_node = node.evaluate()
+            new_node = node.fold()
         except UnfoldableNode:
             continue
 
@@ -79,7 +79,7 @@ def replace_subscripts(vyper_module: vy_ast.Module) -> int:
 
     for node in vyper_module.get_descendants(vy_ast.Subscript, reverse=True):
         try:
-            new_node = node.evaluate()
+            new_node = node.fold()
         except UnfoldableNode:
             continue
 
@@ -114,10 +114,10 @@ def replace_builtin_functions(vyper_module: vy_ast.Module) -> int:
 
         name = node.func.id
         func = DISPATCH_TABLE.get(name)
-        if func is None or not hasattr(func, "evaluate"):
+        if func is None or not hasattr(func, "fold"):
             continue
         try:
-            new_node = func.evaluate(node)  # type: ignore
+            new_node = func.fold(node)  # type: ignore
         except UnfoldableNode:
             continue
 

vyper/ast/nodes.py

@@ -366,15 +366,15 @@ def prefold(self) -> Optional["VyperNode"]:
         """
         return None
 
-    def evaluate(self) -> "VyperNode":
+    def fold(self) -> "VyperNode":
         """
         Attempt to evaluate the content of a node and generate a new node from it.
 
-        If a node cannot be evaluated it should raise `UnfoldableNode`. This base
+        If a node cannot be evaluated, it should raise `UnfoldableNode`. This base
         method acts as a catch-all to raise on any inherited classes that do not
         implement the method.
         """
-        raise UnfoldableNode(f"{type(self)} cannot be evaluated")
+        raise UnfoldableNode(f"{type(self)} cannot be folded")
 
     def validate(self) -> None:
         """
@@ -929,7 +929,7 @@ def prefold(self) -> Optional[ExprNode]:
 
         return None
 
-    def evaluate(self) -> ExprNode:
+    def fold(self) -> ExprNode:
         """
         Attempt to evaluate the unary operation.
 
@@ -992,7 +992,7 @@ def prefold(self) -> Optional[ExprNode]:
         value = self.op._op(left.value, right.value)
         return type(left).from_node(self, value=value)
 
-    def evaluate(self) -> ExprNode:
+    def fold(self) -> ExprNode:
         """
         Attempt to evaluate the arithmetic operation.
 
@@ -1143,7 +1143,7 @@ def prefold(self) -> Optional[ExprNode]:
         value = self.op._op(values)
         return NameConstant.from_node(self, value=value)
 
-    def evaluate(self) -> ExprNode:
+    def fold(self) -> ExprNode:
         """
         Attempt to evaluate the boolean operation.
 
@@ -1209,7 +1209,7 @@ def prefold(self) -> Optional[ExprNode]:
         value = self.op._op(left.value, right.value)
         return NameConstant.from_node(self, value=value)
 
-    def evaluate(self) -> ExprNode:
+    def fold(self) -> ExprNode:
         """
         Attempt to evaluate the comparison.
 
@@ -1320,7 +1320,7 @@ def prefold(self) -> Optional[ExprNode]:
 
         return value.elements[slice_.value]
 
-    def evaluate(self) -> ExprNode:
+    def fold(self) -> ExprNode:
         """
         Attempt to evaluate the subscript.
 

vyper/ast/nodes.pyi

@@ -27,7 +27,7 @@ class VyperNode:
     @classmethod
     def get_fields(cls: Any) -> set: ...
     def prefold(self) -> Optional[VyperNode]: ...
-    def evaluate(self) -> VyperNode: ...
+    def fold(self) -> VyperNode: ...
     @classmethod
     def from_node(cls, node: VyperNode, **kwargs: Any) -> Any: ...
     def to_dict(self) -> dict: ...