remove folded ast output

vyper/ast/natspec.py

@@ -11,13 +11,13 @@
 USERDOCS_FIELDS = ("notice",)
 
 
-def parse_natspec(vyper_module_folded: vy_ast.Module) -> Tuple[dict, dict]:
+def parse_natspec(vyper_module_annotated: vy_ast.Module) -> Tuple[dict, dict]:
     """
     Parses NatSpec documentation from a contract.
 
     Arguments
     ---------
-    vyper_module_folded : Module
+    vyper_module_annotated : Module
         Module-level vyper ast node.
     interface_codes: Dict, optional
         Dict containing relevant data for any import statements related to
@@ -33,15 +33,15 @@ def parse_natspec(vyper_module_folded: vy_ast.Module) -> Tuple[dict, dict]:
     from vyper.semantics.types.function import FunctionVisibility
 
     userdoc, devdoc = {}, {}
-    source: str = vyper_module_folded.full_source_code
+    source: str = vyper_module_annotated.full_source_code
 
-    docstring = vyper_module_folded.get("doc_string.value")
+    docstring = vyper_module_annotated.get("doc_string.value")
     if docstring:
         devdoc.update(_parse_docstring(source, docstring, ("param", "return")))
         if "notice" in devdoc:
             userdoc["notice"] = devdoc.pop("notice")
 
-    for node in [i for i in vyper_module_folded.body if i.get("doc_string.value")]:
+    for node in [i for i in vyper_module_annotated.body if i.get("doc_string.value")]:
         docstring = node.doc_string.value
         func_type = node._metadata["func_type"]
         if func_type.visibility != FunctionVisibility.EXTERNAL:

vyper/compiler/output.py

@@ -32,17 +32,17 @@ def build_annotated_ast_dict(compiler_data: CompilerData) -> dict:
 
 
 def build_devdoc(compiler_data: CompilerData) -> dict:
-    userdoc, devdoc = parse_natspec(compiler_data.vyper_module_folded)
+    userdoc, devdoc = parse_natspec(compiler_data.vyper_module_annotated)
     return devdoc
 
 
 def build_userdoc(compiler_data: CompilerData) -> dict:
-    userdoc, devdoc = parse_natspec(compiler_data.vyper_module_folded)
+    userdoc, devdoc = parse_natspec(compiler_data.vyper_module_annotated)
     return userdoc
 
 
 def build_external_interface_output(compiler_data: CompilerData) -> str:
-    interface = compiler_data.vyper_module_folded._metadata["type"].interface
+    interface = compiler_data.vyper_module_annotated._metadata["type"].interface
     stem = PurePath(compiler_data.contract_path).stem
     # capitalize words separated by '_'
     # ex: test_interface.vy -> TestInterface
@@ -61,7 +61,7 @@ def build_external_interface_output(compiler_data: CompilerData) -> str:
 
 
 def build_interface_output(compiler_data: CompilerData) -> str:
-    interface = compiler_data.vyper_module_folded._metadata["type"].interface
+    interface = compiler_data.vyper_module_annotated._metadata["type"].interface
     out = ""
 
     if interface.events:
@@ -166,7 +166,7 @@ def _to_dict(func_t):
 
 
 def build_method_identifiers_output(compiler_data: CompilerData) -> dict:
-    module_t = compiler_data.vyper_module_folded._metadata["type"]
+    module_t = compiler_data.vyper_module_annotated._metadata["type"]
     functions = module_t.function_defs
 
     return {
@@ -175,7 +175,7 @@ def build_method_identifiers_output(compiler_data: CompilerData) -> dict:
 
 
 def build_abi_output(compiler_data: CompilerData) -> list:
-    module_t = compiler_data.vyper_module_folded._metadata["type"]
+    module_t = compiler_data.vyper_module_annotated._metadata["type"]
     _ = compiler_data.ir_runtime  # ensure _ir_info is generated
 
     abi = module_t.interface.to_toplevel_abi_dict()

vyper/compiler/phases.py

@@ -1,8 +1,7 @@
-import copy
 import warnings
 from functools import cached_property
 from pathlib import Path, PurePath
-from typing import Optional, Tuple
+from typing import Optional
 
 from vyper import ast as vy_ast
 from vyper.codegen import module
@@ -54,9 +53,7 @@ class CompilerData:
     vyper_module : vy_ast.Module
         Top-level Vyper AST node
     vyper_module_annotated : vy_ast.Module
-        Annotated but unfolded Vyper AST
-    vyper_module_folded : vy_ast.Module
-        Annotated and folded Vyper AST
+        Annotated Vyper AST
     global_ctx : ModuleT
         Sorted, contextualized representation of the Vyper AST
     ir_nodes : IRnode
@@ -154,28 +151,24 @@ def vyper_module(self):
         return self._generate_ast
 
     @cached_property
-    def vyper_module_annotated(self) -> vy_ast.Module:
-        return generate_annotated_ast(self.vyper_module, self.input_bundle)
-
-    @cached_property
-    def _folded_module(self):
-        return generate_folded_ast(
-            self.vyper_module_annotated, self.input_bundle, self.storage_layout_override
+    def _annotated_module(self):
+        return generate_annotated_ast(
+            self.vyper_module, self.input_bundle, self.storage_layout_override
         )
 
     @property
-    def vyper_module_folded(self) -> vy_ast.Module:
-        module, storage_layout = self._folded_module
+    def vyper_module_annotated(self) -> vy_ast.Module:
+        module, storage_layout = self._annotated_module
         return module
 
     @property
     def storage_layout(self) -> StorageLayout:
-        module, storage_layout = self._folded_module
+        module, storage_layout = self._annotated_module
         return storage_layout
 
     @property
     def global_ctx(self) -> ModuleT:
-        return self.vyper_module_folded._metadata["type"]
+        return self.vyper_module_annotated._metadata["type"]
 
     @cached_property
     def _ir_output(self):
@@ -204,7 +197,7 @@ def function_signatures(self) -> dict[str, ContractFunctionT]:
         # ensure codegen is run:
         _ = self._ir_output
 
-        fs = self.vyper_module_folded.get_children(vy_ast.FunctionDef)
+        fs = self.vyper_module_annotated.get_children(vy_ast.FunctionDef)
         return {f.name: f._metadata["func_type"] for f in fs}
 
     @cached_property
@@ -246,24 +239,13 @@ def blueprint_bytecode(self) -> bytes:
         return deploy_bytecode + blueprint_bytecode
 
 
-# destructive -- mutates module in place!
-def generate_annotated_ast(vyper_module: vy_ast.Module, input_bundle: InputBundle) -> vy_ast.Module:
-    vy_ast.validation.validate_literal_nodes(vyper_module)
-
-    with input_bundle.search_path(Path(vyper_module.resolved_path).parent):
-        # note: validate_semantics does type inference on the AST
-        validate_semantics(vyper_module, input_bundle)
-
-    return vyper_module
-
-
-def generate_folded_ast(
+def generate_annotated_ast(
     vyper_module: vy_ast.Module,
     input_bundle: InputBundle,
     storage_layout_overrides: StorageLayout = None,
-) -> Tuple[vy_ast.Module, StorageLayout]:
+) -> tuple[vy_ast.Module, StorageLayout]:
     """
-    Perform constant folding operations on the Vyper AST.
+    Validates and annotates the Vyper AST.
 
     Arguments
     ---------
@@ -277,12 +259,15 @@ def generate_folded_ast(
     StorageLayout
         Layout of variables in storage
     """
-    symbol_tables = set_data_positions(vyper_module, storage_layout_overrides)
+    vy_ast.validation.validate_literal_nodes(vyper_module)
 
-    vyper_module_folded = copy.deepcopy(vyper_module)
-    # vy_ast.folding.fold(vyper_module_folded)
+    with input_bundle.search_path(Path(vyper_module.resolved_path).parent):
+        # note: validate_semantics does type inference on the AST
+        validate_semantics(vyper_module, input_bundle)
+
+    symbol_tables = set_data_positions(vyper_module, storage_layout_overrides)
 
-    return vyper_module_folded, symbol_tables
+    return vyper_module, symbol_tables
 
 
 def generate_ir_nodes(

vyper/semantics/analysis/module.py

@@ -495,7 +495,6 @@ def _parse_and_fold_ast(file: FileInput) -> vy_ast.VyperNode:
         resolved_path=str(file.resolved_path),
     )
     vy_ast.validation.validate_literal_nodes(ret)
-    # vy_ast.folding.fold(ret)
 
     return ret