vyper 0.4.0 support

boa/contracts/vyper/ast_utils.py

@@ -4,7 +4,6 @@
 from typing import Any, Optional
 
 import vyper.ast as vy_ast
-from vyper.codegen.core import getpos
 
 
 def get_block(source_code: str, lineno: int, end_lineno: int) -> str:
@@ -44,15 +43,6 @@ def reason_at(
     return None
 
 
-# build a reverse map from the format we have in pc_pos_map to AST nodes
-def ast_map_of(ast_node):
-    ast_map = {}
-    nodes = [ast_node] + ast_node.get_descendants(reverse=True)
-    for node in nodes:
-        ast_map[getpos(node)] = node
-    return ast_map
-
-
 def get_fn_name_from_lineno(ast_map: dict, lineno: int) -> str:
     # TODO: this could be a performance bottleneck
     for source_map, node in ast_map.items():

boa/contracts/vyper/compiler_utils.py

@@ -1,13 +1,15 @@
-import contextlib
 import textwrap
 
 import vyper.ast as vy_ast
 import vyper.semantics.analysis as analysis
-from vyper.ast.utils import parse_to_ast
-from vyper.codegen.core import anchor_opt_level
-from vyper.codegen.function_definitions import generate_ir_for_function
+from vyper.ast.parse import parse_to_ast
+from vyper.codegen.function_definitions import (
+    generate_ir_for_external_function,
+    generate_ir_for_internal_function,
+)
 from vyper.codegen.ir_node import IRnode
-from vyper.evm.opcodes import anchor_evm_version
+from vyper.codegen.module import _runtime_reachable_functions
+from vyper.compiler.settings import anchor_settings
 from vyper.exceptions import InvalidType
 from vyper.ir import compile_ir, optimizer
 from vyper.semantics.analysis.utils import get_exact_type_from_node
@@ -18,13 +20,6 @@
 _METHOD_ID_VAR = "_calldata_method_id"
 
 
-@contextlib.contextmanager
-def anchor_compiler_settings(compiler_data):
-    settings = compiler_data.settings
-    with anchor_opt_level(settings.optimize), anchor_evm_version(settings.evm_version):
-        yield
-
-
 def compile_vyper_function(vyper_function, contract):
     """Compiles a vyper function and appends it to the top of the IR of a
     contract. This is useful for vyper `eval` and internal functions, where
@@ -35,22 +30,20 @@ def compile_vyper_function(vyper_function, contract):
 
     compiler_data = contract.compiler_data
 
-    with anchor_compiler_settings(compiler_data):
-        global_ctx = contract.global_ctx
-        ifaces = compiler_data.interface_codes
-        ast = parse_to_ast(vyper_function, ifaces)
-        vy_ast.folding.fold(ast)
+    with anchor_settings(compiler_data.settings):
+        module_t = contract.module_t
+        ast = parse_to_ast(vyper_function)
 
         # override namespace and add wrapper code at the top
         with contract.override_vyper_namespace():
-            analysis.add_module_namespace(ast, ifaces)
-            analysis.validate_functions(ast)
+            analysis.analyze_module(ast, compiler_data.input_bundle)
 
         ast = ast.body[0]
-        func_t = ast._metadata["type"]
+        func_t = ast._metadata["func_type"]
 
-        external_func_info = generate_ir_for_function(ast, global_ctx, False)
-        ir = external_func_info.common_ir
+        contract.ensure_id(func_t)
+        funcinfo = generate_ir_for_external_function(ast, module_t)
+        ir = funcinfo.common_ir
 
         entry_label = func_t._ir_info.external_function_base_entry_label
 
@@ -63,7 +56,20 @@ def compile_vyper_function(vyper_function, contract):
         # all labels are present, and then optimize all together
         # (use unoptimized IR, ir_executor can't handle optimized selector tables)
         _, contract_runtime = contract.unoptimized_ir
-        ir = IRnode.from_list(["seq", ir, contract_runtime])
+        ir_list = ["seq", ir, contract_runtime]
+        reachable = func_t.reachable_internal_functions
+
+        already_compiled = _runtime_reachable_functions(module_t, contract)
+        missing_functions = reachable.difference(already_compiled)
+        # TODO: cache function compilations or something
+        for f in missing_functions:
+            assert f.ast_def is not None
+            contract.ensure_id(f)
+            ir_list.append(
+                generate_ir_for_internal_function(f.ast_def, module_t, False).func_ir
+            )
+
+        ir = IRnode.from_list(ir_list)
         ir = optimizer.optimize(ir)
 
         assembly = compile_ir.compile_to_assembly(ir)
@@ -119,7 +125,7 @@ def generate_bytecode_for_arbitrary_stmt(source_code, contract):
     """Wraps arbitrary stmts with external fn and generates bytecode"""
 
     ast = parse_to_ast(source_code)
-    vy_ast.folding.fold(ast)
+
     ast = ast.body[0]
 
     return_sig = ""

boa/contracts/vyper/ir_executor.py

@@ -11,9 +11,12 @@
 from eth.exceptions import Revert as VMRevert
 from eth.exceptions import WriteProtection
 from eth_hash.auto import keccak
+from vyper.ast.nodes import VyperNode
+from vyper.codegen.ir_node import IRnode
 from vyper.compiler.phases import CompilerData
 from vyper.evm.opcodes import OPCODES
-from vyper.utils import mkalphanum, unsigned_to_signed
+from vyper.ir.compile_ir import getpos
+from vyper.utils import unsigned_to_signed
 
 from boa.util.lrudict import lrudict
 from boa.vm.fast_mem import FastMem
@@ -27,6 +30,11 @@ def keccak256(x):
     return _keccak_cache.setdefault_lambda(x, keccak)
 
 
+def _mkalphanum(string):
+    # map a string to only-alphanumeric chars
+    return "".join([c if c.isalnum() else "_" for c in string])
+
+
 @dataclass
 class _Line:
     indentation_level: int
@@ -97,10 +105,10 @@ def freshvar(self, name=""):
 
     @cached_property
     def contract_name(self):
-        return mkalphanum(PurePath(self.vyper_compiler_data.contract_name).name)
+        return _mkalphanum(PurePath(self.vyper_compiler_data.contract_path).name)
 
     def translate_label(self, label):
-        return f"{self.contract_name}_{self.uuid}_{label}"
+        return _mkalphanum(f"{self.contract_name}_{self.uuid}_{label}")
 
     def add_unique_symbol(self, symbol):
         if symbol in self.unique_symbols:  # pragma: no cover
@@ -236,7 +244,7 @@ def compile(self, out=None, out_typ=None):
     def _compile(self, context):  # pragma: no cover
         raise RuntimeError("must be overridden in subclass!")
 
-    def compile_main(self, contract_path=""):
+    def compile_main(self, contract_name=""):
         self.builder.extend("import vyper.utils\nimport _operator")
 
         main_name = self.compile_ctx.translate_label("main")
@@ -248,7 +256,7 @@ def compile_main(self, contract_path=""):
             self.builder.extend("\n\n")
             func.compile_func()
 
-        py_file = f"{contract_path}{self.compile_ctx.uuid}.py"
+        py_file = f"{contract_name}{self.compile_ctx.uuid}.py"
 
         # uncomment for debugging the python code:
         # with open(py_file, "w") as f:
@@ -838,7 +846,7 @@ def _compile(self, test):
         self.builder.extend(
             f"""
         if not bool({test}):
-            VM.vyper_source_pos = {repr(self.ir_node.source_pos)}
+            VM.vyper_source_pos = {repr(_get_ir_pos(self.ir_node))}
             VM.vyper_error_msg = {repr(self.ir_node.error_msg)}
             raise VMRevert("")  # venom assert
         """
@@ -854,7 +862,7 @@ def _compile(self, ptr, size):
         self.builder.extend(
             f"""
             VM.output = VM.memory_read_bytes({ptr}, {size})
-            VM.vyper_source_pos = {repr(self.ir_node.source_pos)}
+            VM.vyper_source_pos = {repr(_get_ir_pos(self.ir_node))}
             VM.vyper_error_msg = {repr(self.ir_node.error_msg)}
             raise VMRevert(VM.output)  # venom revert
         """
@@ -1114,24 +1122,27 @@ def compile(self, **kwargs):
         val.compile(out=variable.out_name, out_typ=int)
 
 
-def _ensure_source_pos(ir_node, source_pos=None, error_msg=None):
-    if ir_node.source_pos is None:
-        ir_node.source_pos = source_pos
+def _ensure_ast_source(
+    ir_node: IRnode, ast_source: VyperNode = None, error_msg: str = None
+):
+    if ir_node.ast_source is None:
+        ir_node.ast_source = ast_source
     if ir_node.error_msg is None:
         ir_node.error_msg = error_msg
     for arg in ir_node.args:
-        _ensure_source_pos(arg, ir_node.source_pos, ir_node.error_msg)
+        _ensure_ast_source(arg, ir_node.ast_source, ir_node.error_msg)
 
 
 def executor_from_ir(ir_node, vyper_compiler_data) -> Any:
-    _ensure_source_pos(ir_node)
-    ret = _executor_from_ir(ir_node, CompileContext(vyper_compiler_data))
+    _ensure_ast_source(ir_node)
+    ctx = CompileContext(vyper_compiler_data)
+    ret = _executor_from_ir(ir_node, ctx)
 
     ret = ret.analyze()
 
     # TODO: rename this, this is "something.vy", but we maybe want
     # "something.py <compiled from .vy>"
-    ret.compile_main(vyper_compiler_data.contract_name)
+    ret.compile_main(ctx.contract_name)
     return ret
 
 
@@ -1152,3 +1163,9 @@ def _executor_from_ir(ir_node, compile_ctx) -> Any:
     assert len(ir_node.args) == 0, ir_node
     assert isinstance(ir_node.value, str)
     return StringExecutor(compile_ctx, ir_node.value)
+
+
+def _get_ir_pos(ir_node):
+    if ir_node.ast_source is None:
+        return None
+    return getpos(ir_node.ast_source)