feat[tool]: add -Werror and -Wnone options (#4447)

this commit adds `-Werror` and `-Wnone` CLI flags which promote
warnings to errors and ignore them, respectively.

also adds some small refactoring for warning handling to simplify the
implementation (allow us to use warnings.simplefilter). this provides
a way moving forward to do fine-grained warnings control, since the
warnings filter allows us to use the exception class in the filter.

---------

Co-authored-by: tserg <[email protected]>

Author: charles-cooper

docs/compiling-a-contract.rst

@@ -198,6 +198,23 @@ The following is a list of supported EVM versions, and changes in the compiler i
    - Functions marked with ``@nonreentrant`` are protected with TLOAD/TSTORE instead of SLOAD/SSTORE
    - The ``MCOPY`` opcode will be generated automatically by the compiler for most memory operations.
 
+
+.. _warnings:
+
+Controlling Warnings
+====================
+
+Vyper allows suppression of warnings via the CLI flag ``-Wnone``, or promotion of (all) warnings to errors via the ``-Werror`` flag.
+
+.. code:: shell
+
+    $ vyper -Wnone foo.vy   # suppress warnings
+
+.. code:: shell
+
+    $ vyper -Werror foo.vy   # promote warnings to errors
+
+
 .. _integrity-hash:
 
 Integrity Hash

tests/functional/syntax/warnings/test_contract_size_limit_warning.py

@@ -0,0 +1,23 @@
+import random
+
+import pytest
+
+import vyper
+
+
+@pytest.fixture
+def huge_bytestring():
+    r = random.Random(b"vyper")
+
+    return bytes([r.getrandbits(8) for _ in range(0x6001)])
+
+
+def test_contract_size_exceeded(huge_bytestring):
+    code = f"""
+@external
+def a() -> bool:
+    q: Bytes[24577] = {huge_bytestring}
+    return True
+"""
+    with pytest.warns(vyper.warnings.ContractSizeLimit):
+        vyper.compile_code(code, output_formats=["bytecode_runtime"])

tests/functional/syntax/warnings/test_deprecation_warning.py

@@ -0,0 +1,50 @@
+import json
+
+import pytest
+
+import vyper
+from vyper.cli.vyper_json import compile_json
+
+deprecated = [
+    """
+struct Foo:
+    a: uint256
+    b: uint256
+
+@external
+def foo():
+    f: Foo = Foo({a: 128, b: 256})
+    """,
+    """
+event Foo:
+    a: uint256
+    b: uint256
+
+@external
+def foo():
+    log Foo({a: 128, b: 256})
+    """,
+]
+
+
+@pytest.mark.parametrize("code", deprecated)
+def test_deprecated_warning(code):
+    with pytest.warns(vyper.warnings.Deprecation):
+        vyper.compile_code(code)
+
+
+def test_deprecated_optimize_boolean_flag():
+    code = """
+@external
+def foo():
+    pass
+    """
+
+    input_json = {
+        "language": "Vyper",
+        "sources": {"contracts/foo.vy": {"content": code}},
+        "settings": {"outputSelection": {"*": ["*"]}, "optimize": True},
+    }
+
+    with pytest.warns(vyper.warnings.Deprecation):
+        compile_json(json.dumps(input_json))

tests/functional/syntax/warnings/test_enum_usage_warning.py

@@ -0,0 +1,18 @@
+import pytest
+
+import vyper
+
+
+def test_enum_usage_warning():
+    code = """
+enum Foo:
+    Fe
+    Fi
+    Fo
+
+@external
+def foo() -> Foo:
+    return Foo.Fe
+    """
+    with pytest.warns(vyper.warnings.EnumUsage):
+        vyper.compile_code(code)

tests/unit/cli/vyper_compile/test_parse_args.py

@@ -1,8 +1,10 @@
 import os
+import warnings
 
 import pytest
 
 from vyper.cli.vyper_compile import _parse_args
+from vyper.warnings import VyperWarning
 
 
 @pytest.fixture
@@ -27,3 +29,33 @@ def foo() -> bool:
 
     _parse_args([str(bar_path)])  # absolute path, subfolder of cwd
     _parse_args([str(bar_path.relative_to(chdir_path.parent))])  # relative path
+
+
+def test_warnings(make_file):
+    """
+    test -Werror and -Wnone
+    """
+    # test code which emits warnings
+    code = """
+x: public(uint256[2**64])
+    """
+    path = make_file("foo.vy", code)
+    path_str = str(path)
+
+    with warnings.catch_warnings(record=True) as w:
+        _parse_args([str(path)])
+
+    with pytest.raises(VyperWarning) as e:
+        _parse_args([path_str, "-Werror"])
+
+    assert len(w) == 1
+    warning_message = w[0].message.message
+
+    assert e.value.message == warning_message
+
+    # test squashing warnings
+    with warnings.catch_warnings(record=True) as w:
+        _parse_args([path_str, "-Wnone"])
+    assert len(w) == 0
+
+    warnings.resetwarnings()

tests/unit/compiler/test_compile_code.py

@@ -1,28 +1,6 @@
-import random
-
-import pytest
-
 import vyper
 
 
-@pytest.fixture
-def huge_bytestring():
-    r = random.Random(b"vyper")
-
-    return bytes([r.getrandbits(8) for _ in range(0x6001)])
-
-
-def test_contract_size_exceeded(huge_bytestring):
-    code = f"""
-@external
-def a() -> bool:
-    q: Bytes[24577] = {huge_bytestring}
-    return True
-"""
-    with pytest.warns(vyper.warnings.ContractSizeLimitWarning):
-        vyper.compile_code(code, output_formats=["bytecode_runtime"])
-
-
 # test that each compilation run gets a fresh analysis and storage allocator
 def test_shared_modules_allocation(make_input_bundle):
     lib1 = """

vyper/ast/nodes.py

@@ -7,7 +7,6 @@
 import operator
 import pickle
 import sys
-import warnings
 from typing import Any, Optional, Union
 
 from vyper.ast.metadata import NodeMetadata
@@ -23,7 +22,6 @@
     TypeMismatch,
     UnfoldableNode,
     VariableDeclarationException,
-    VyperException,
     ZeroDivisionException,
 )
 from vyper.utils import (
@@ -34,6 +32,7 @@
     quantize,
     sha256sum,
 )
+from vyper.warnings import EnumUsage, vyper_warn
 
 NODE_BASE_ATTRIBUTES = (
     "_children",
@@ -133,13 +132,9 @@ def get_node(
 
     node = vy_class(parent=parent, **ast_struct)
 
-    # TODO: Putting this after node creation to pretty print, remove after enum deprecation
     if enum_warn:
-        # TODO: hack to pretty print, logic should be factored out of exception
-        pretty_printed_node = str(VyperException("", node))
-        warnings.warn(
-            f"enum will be deprecated in a future release, use flag instead. {pretty_printed_node}",
-            stacklevel=2,
+        vyper_warn(
+            EnumUsage("enum will be deprecated in a future release, use flag instead.", node)
         )
 
     node.validate()

vyper/ast/parse.py

@@ -9,7 +9,8 @@
 from vyper.ast.pre_parser import PreParser
 from vyper.compiler.settings import Settings
 from vyper.exceptions import CompilerPanic, ParserException, SyntaxException
-from vyper.utils import sha256sum, vyper_warn
+from vyper.utils import sha256sum
+from vyper.warnings import Deprecation, vyper_warn
 
 
 def parse_to_ast(*args: Any, **kwargs: Any) -> vy_ast.Module:
@@ -442,7 +443,7 @@ def visit_Call(self, node):
 
             # add full_source_code so that str(VyperException(msg, node)) works
             node.full_source_code = self._source_code
-            vyper_warn(msg, node)
+            vyper_warn(Deprecation(msg, node))
 
             dict_ = node.args[0]
             kw_list = []

vyper/builtins/functions.py

@@ -96,8 +96,8 @@
     keccak256,
     method_id,
     method_id_int,
-    vyper_warn,
 )
+from vyper.warnings import vyper_warn
 
 from ._convert import convert
 from ._signatures import BuiltinFunctionT, process_inputs

vyper/cli/vyper_compile.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
 import argparse
+import functools
+import inspect
 import json
 import os
 import sys
-import warnings
 from pathlib import Path
 from typing import Any, Optional
 
@@ -16,6 +17,7 @@
 from vyper.compiler.settings import VYPER_TRACEBACK_LIMIT, OptimizationLevel, Settings
 from vyper.typing import ContractPath, OutputFormats
 from vyper.utils import uniq
+from vyper.warnings import warnings_filter
 
 format_options_help = """Format to print, one or more of (comma-separated):
 bytecode (default) - Deployable bytecode
@@ -97,8 +99,6 @@ def _cli_helper(f, output_formats, compiled):
 
 
 def _parse_args(argv):
-    warnings.simplefilter("always")
-
     if "--standard-json" in argv:
         argv.remove("--standard-json")
         vyper_json._parse_args(argv)
@@ -186,6 +186,10 @@ def _parse_args(argv):
     )
     parser.add_argument("--enable-decimals", help="Enable decimals", action="store_true")
 
+    parser.add_argument(
+        "-W", help="Control warnings", dest="warnings_control", choices=["error", "none"]
+    )
+
     args = parser.parse_args(argv)
 
     if args.traceback_limit is not None:
@@ -247,6 +251,7 @@ def _parse_args(argv):
         settings,
         args.storage_layout,
         args.no_bytecode_metadata,
+        args.warnings_control,
     )
 
     mode = "w"
@@ -290,6 +295,21 @@ def get_search_paths(paths: list[str] = None, include_sys_path=True) -> list[Pat
     return search_paths
 
 
+def _apply_warnings_filter(func):
+    @functools.wraps(func)
+    def inner(*args, **kwargs):
+        # find "warnings_control" argument
+        ba = inspect.signature(func).bind(*args, **kwargs)
+        ba.apply_defaults()
+
+        warnings_control = ba.arguments["warnings_control"]
+        with warnings_filter(warnings_control):
+            return func(*args, **kwargs)
+
+    return inner
+
+
+@_apply_warnings_filter
 def compile_files(
     input_files: list[str],
     output_formats: OutputFormats,
@@ -299,6 +319,7 @@ def compile_files(
     settings: Optional[Settings] = None,
     storage_layout_paths: list[str] = None,
     no_bytecode_metadata: bool = False,
+    warnings_control: Optional[str] = None,
 ) -> dict:
     search_paths = get_search_paths(paths, include_sys_path)
     input_bundle = FilesystemInputBundle(search_paths)