fix[lang]: disallow staticcall in pure context

tests/functional/builtins/codegen/test_raw_call.py

@@ -644,6 +644,25 @@ def foo(_addr: address):
     """,
         TypeMismatch,
     ),
+    (
+        """
+@pure
+@external
+def foo(a: address):
+    # test staticcall detection from pure function
+    x: Bytes[32] = raw_call(a, b'', max_outsize=32, is_static_call=True)
+    """,
+        StateAccessViolation,
+    ),
+    (
+        """
+@pure
+def foo(a: address):
+    # test staticcall detection from pure function with constant folding
+    x: Bytes[32] = raw_call(a, b'', max_outsize=32, is_static_call=True or False)
+    """,
+        StateAccessViolation,
+    ),
 ]
 
 

vyper/builtins/functions.py

@@ -1054,6 +1054,18 @@ def infer_arg_types(self, node, expected_return_typ=None):
         data_type = get_possible_types_from_node(node.args[1]).pop()
         return [self._inputs[0][1], data_type]
 
+    # get the mutability, which is determined at a specific call site
+    def get_mutability_at_call_site(self, node: vy_ast.Call):
+        kw = {k.arg: k.value for k in node.keywords}
+
+        is_static = kw.get("is_static_call", None)
+        is_static = is_static.get_folded_value() if is_static else False
+
+        if is_static:
+            return StateMutability.VIEW
+
+        return StateMutability.NONPAYABLE
+
     @process_inputs
     def build_IR(self, expr, args, kwargs, context):
         to, data = args

vyper/semantics/analysis/local.py

@@ -846,7 +846,16 @@ def visit_Call(self, node: vy_ast.Call, typ: VyperType) -> None:
         else:
             # builtin functions and interfaces
             if self.function_analyzer and hasattr(func_type, "mutability"):
-                self._check_call_mutability(func_type.mutability)  # type: ignore
+                from vyper.builtins.functions import RawCall
+
+                if isinstance(func_type, RawCall):
+                    # as opposed to other functions, raw_call's mutability
+                    # depends on its arguments, so we need to determine
+                    # it at each call site.
+                    mutability = func_type.get_mutability_at_call_site(node)
+                else:
+                    mutability = func_type.mutability
+                self._check_call_mutability(mutability)  # type: ignore
 
             arg_types = func_type.infer_arg_types(node, expected_return_typ=typ)  # type: ignore
             for arg, arg_type in zip(node.args, arg_types):