Upgrade to Next

tests/cli/vyper_json/test_compile_from_input_dict.py

@@ -11,7 +11,7 @@
     exc_handler_raises,
     exc_handler_to_dict,
 )
-from vyper.exceptions import JSONError, SyntaxException, TypeMismatch
+from vyper.exceptions import InvalidType, JSONError, SyntaxException
 
 FOO_CODE = """
 import contracts.bar as Bar
@@ -98,7 +98,7 @@ def test_exc_handler_to_dict_syntax():
 def test_exc_handler_raises_compiler():
     input_json = deepcopy(INPUT_JSON)
     input_json['sources']['badcode.vy'] = {'content': BAD_COMPILER_CODE}
-    with pytest.raises(TypeMismatch):
+    with pytest.raises(InvalidType):
         compile_from_input_dict(input_json, exc_handler_raises)
 
 
@@ -111,7 +111,7 @@ def test_exc_handler_to_dict_compiler():
     assert len(result['errors']) == 1
     error = result['errors'][0]
     assert error['component'] == "compiler"
-    assert error['type'] == "TypeMismatch"
+    assert error['type'] == "InvalidType"
 
 
 def test_source_ids_increment():

tests/compiler/test_pre_parser.py

@@ -20,7 +20,7 @@ def test_valid_semicolons(get_contract):
 def test() -> int128:
     a: int128 = 1
     b: int128 = 2
-    s: bytes[300] = "this should not be a problem; because it is in a string"
+    s: string[300] = "this should not be a problem; because it is in a string"
     s = \"\"\"this should not be a problem; because it's in a string\"\"\"
     s = 'this should not be a problem;;; because it\\\'s in a string'
     s = '''this should not ; \'cause it\'s in a string'''

tests/functional/context/conftest.py

@@ -0,0 +1,32 @@
+import pytest
+
+from vyper import ast as vy_ast
+from vyper.context.namespace import get_namespace
+
+
+@pytest.fixture(scope="session")
+def build_node():
+    """
+    Yields a helper function for generating a single Vyper AST node.
+    """
+
+    def _build_node(source):
+        # docstring ensures string nodes are properly generated, not turned into docstrings
+        source = f"""'I am a docstring.'\n{source}"""
+        ast = vy_ast.parse_to_ast(source).body[0]
+        if isinstance(ast, vy_ast.Expr):
+            ast = ast.value
+        return ast
+
+    yield _build_node
+
+
+@pytest.fixture
+def namespace():
+    """
+    Yields a clean `Namespace` object.
+    """
+    obj = get_namespace()
+    obj.clear()
+    yield obj
+    obj.clear()

tests/functional/context/test_namespace.py

@@ -0,0 +1,119 @@
+import pytest
+
+from vyper.context import environment
+from vyper.context.namespace import get_namespace
+from vyper.context.types import get_types
+from vyper.exceptions import (
+    CompilerPanic,
+    NamespaceCollision,
+    UndeclaredDefinition,
+)
+
+
+def test_get_namespace(namespace):
+    ns = get_namespace()
+    ns2 = get_namespace()
+    assert ns == ns2 == namespace
+
+
+def test_clear(namespace):
+    namespace["foo"] = 42
+    assert "foo" in namespace
+
+    namespace.clear()
+    assert "foo" not in namespace
+
+
+def test_builtin_context_manager(namespace):
+    namespace["foo"] = 42
+    with namespace.enter_builtin_scope():
+        namespace["bar"] = 1337
+
+    assert namespace["foo"] == 42
+    assert "bar" not in namespace
+
+
+def test_builtin_context_manager_types(namespace):
+    with namespace.enter_builtin_scope():
+        for key, value in get_types().items():
+            assert namespace[key] == value
+
+    for key, value in get_types().items():
+        assert namespace[key] == value
+
+
+def test_builtin_context_manager_conamespacetant_vars(namespace):
+    with namespace.enter_builtin_scope():
+        for key in environment.CONSTANT_ENVIRONMENT_VARS.keys():
+            assert key in namespace
+
+    for key in environment.CONSTANT_ENVIRONMENT_VARS.keys():
+        assert key in namespace
+
+
+def test_builtin_context_manager_mutable_vars(namespace):
+    with namespace.enter_builtin_scope():
+        for key in environment.MUTABLE_ENVIRONMENT_VARS.keys():
+            assert key in namespace
+
+    for key in environment.MUTABLE_ENVIRONMENT_VARS.keys():
+        assert key not in namespace
+
+
+def test_builtin_context_manager_wrong_sequence(namespace):
+    with namespace.enter_builtin_scope():
+        # fails because builtin scope may only be entered once
+        with pytest.raises(CompilerPanic):
+            with namespace.enter_builtin_scope():
+                pass
+
+
+def test_context_manager(namespace):
+    with namespace.enter_builtin_scope():
+        namespace["foo"] = 42
+        with namespace.enter_scope():
+            namespace["bar"] = 1337
+
+        assert namespace["foo"] == 42
+        assert "bar" not in namespace
+
+    assert "foo" not in namespace
+
+
+def test_context_manager_wrong_sequence(namespace):
+    with pytest.raises(CompilerPanic):
+        with namespace.enter_scope():
+            pass
+
+
+def test_incorrect_context_invokation(namespace):
+    with pytest.raises(CompilerPanic):
+        with namespace:
+            pass
+
+
+def test_namespace_collision(namespace):
+    namespace["foo"] = 42
+    with pytest.raises(NamespaceCollision):
+        namespace["foo"] = 1337
+
+
+def test_namespace_collision_across_scopes(namespace):
+    with namespace.enter_builtin_scope():
+        namespace["foo"] = 42
+        with namespace.enter_scope():
+            with pytest.raises(NamespaceCollision):
+                namespace["foo"] = 1337
+
+
+def test_undeclared_definition(namespace):
+    with pytest.raises(UndeclaredDefinition):
+        namespace["foo"]
+
+
+def test_undeclared_definition_across_scopes(namespace):
+    with namespace.enter_builtin_scope():
+        with namespace.enter_scope():
+            namespace["foo"] = 42
+    with pytest.raises(UndeclaredDefinition):
+        namespace["foo"]

tests/functional/context/types/test_pure_types.py

@@ -0,0 +1,132 @@
+import pytest
+
+from vyper.context.types.value.address import AddressPrimitive
+from vyper.context.types.value.array_value import (
+    BytesArrayPrimitive,
+    StringPrimitive,
+)
+from vyper.context.types.value.boolean import BoolPrimitive
+from vyper.context.types.value.bytes_fixed import Bytes32Primitive
+from vyper.context.types.value.numeric import (
+    DecimalPrimitive,
+    Int128Primitive,
+    Uint256Primitive,
+)
+from vyper.exceptions import (
+    InvalidLiteral,
+    OverflowException,
+    StructureException,
+    UnexpectedNodeType,
+    UnexpectedValue,
+)
+
+BASE_SOURCE = """
+"Add a docstring so the target test node doesn't become one."
+"""
+
+PRIMITIVES = {
+    AddressPrimitive: "address",
+    BoolPrimitive: "bool",
+    Bytes32Primitive: "bytes32",
+    BytesArrayPrimitive: "bytes[1]",
+    DecimalPrimitive: "decimal",
+    Int128Primitive: "int128",
+    StringPrimitive: "string[1]",
+    Uint256Primitive: "uint256",
+}
+
+
+VALID_LITERALS = {
+    AddressPrimitive: ["0x6B175474E89094C44Da98b954EedeAC495271d0F"],
+    BoolPrimitive: ["True", "False"],
+    Bytes32Primitive: ["0x6B175474E89094C44Da98b954EedeAC495271d0F4Da98b954EedeAC495271d0F"],
+    BytesArrayPrimitive: [
+        "b''",
+        "b'this is thirty three bytes long!!'",
+        r"b'\xbe\xef'",
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F4Da98b954EedeAC495271d0F",
+    ],
+    DecimalPrimitive: ["-1.666", "3.31337", "8008135.0", "1.2345678901"],
+    Int128Primitive: ["-1", "0", "12", "42"],
+    StringPrimitive: ["''", "'hello'", "'this is thirty three chars long!!'", "'-42'"],
+    Uint256Primitive: ["0", "12", "42"],
+}
+
+INVALID_LITERALS = [
+    "None",
+    "115792089237316195423570985008687907853269984665640564039457584007913129639936",
+    "115792089237316195423570985008687907853269984665640564039457584007913129639935.1",
+]
+INVALID_NODES = [
+    "self.{}",
+    "[{}]",
+    "({},)",
+    "{}()",
+    "{}(foo)",
+    "{}.foo",
+    "public({})",
+    "-{}",
+    "{}[1]",
+    "self.{}[1]",
+]
+
+
+# source is a combined list made from all lists in  VALID_LITERALS and INVALID_LITERALS
+@pytest.mark.parametrize(
+    "source", [x for v in VALID_LITERALS.values() for x in v] + INVALID_LITERALS
+)
+@pytest.mark.parametrize("Primitive", VALID_LITERALS.keys())
+def test_from_literal(build_node, Primitive, source):
+    node = build_node(source)
+
+    if source in VALID_LITERALS[Primitive]:
+        obj = Primitive.from_literal(node)
+        assert isinstance(obj, Primitive._type)
+    else:
+        with pytest.raises((InvalidLiteral, OverflowException)):
+            Primitive.from_literal(node)
+
+
+@pytest.mark.parametrize("Primitive,type_str", PRIMITIVES.items())
+@pytest.mark.parametrize("source", INVALID_NODES + ["{}"])
+def test_from_literal_invalid_node(build_node, Primitive, type_str, source):
+    source = source.format(type_str)
+    node = build_node(source)
+
+    with pytest.raises(UnexpectedNodeType):
+        Primitive.from_literal(node)
+
+
+@pytest.mark.parametrize("Primitive", VALID_LITERALS.keys())
+@pytest.mark.parametrize(
+    "source", [x for v in VALID_LITERALS.values() for x in v] + INVALID_LITERALS
+)
+def test_from_annotation_literal(build_node, Primitive, source):
+    node = build_node(source)
+
+    with pytest.raises(StructureException):
+        BoolPrimitive.from_annotation(node)
+
+
+@pytest.mark.parametrize("Primitive,type_str", PRIMITIVES.items())
+@pytest.mark.parametrize("source", INVALID_NODES)
+def test_from_annotation_invalid_structure(build_node, Primitive, type_str, source):
+    source = source.format(type_str)
+    node = build_node(source)
+
+    with pytest.raises((UnexpectedValue, StructureException)):
+        Primitive.from_annotation(node)
+
+
+@pytest.mark.parametrize("Primitive", PRIMITIVES.keys())
+@pytest.mark.parametrize("type_str", PRIMITIVES.values())
+def test_from_annotation_wrong_id(build_node, Primitive, type_str):
+    node = build_node(type_str)
+
+    if type_str == PRIMITIVES[Primitive]:
+        obj = Primitive.from_annotation(node)
+        assert isinstance(obj, Primitive._type)
+    else:
+        with pytest.raises((UnexpectedValue, StructureException)):
+            Primitive.from_annotation(node)

tests/functional/context/types/test_type_from_abi.py

@@ -0,0 +1,51 @@
+import pytest
+
+from vyper.context.types import get_primitive_types
+from vyper.context.types.indexable.sequence import ArrayDefinition
+from vyper.context.types.utils import get_type_from_abi
+from vyper.exceptions import UnknownType
+
+BASE_TYPES = ["int128", "uint256", "bool", "address", "bytes32"]
+
+
+@pytest.mark.parametrize("type_str", BASE_TYPES)
+def test_base_types(namespace, type_str):
+    primitive = get_primitive_types()[type_str]
+
+    with namespace.enter_builtin_scope():
+        type_definition = get_type_from_abi({"type": type_str})
+
+    assert isinstance(type_definition, primitive._type)
+
+
+@pytest.mark.parametrize("type_str", BASE_TYPES)
+def test_base_types_as_arrays(namespace, type_str):
+    primitive = get_primitive_types()[type_str]
+
+    with namespace.enter_builtin_scope():
+        type_definition = get_type_from_abi({"type": f"{type_str}[3]"})
+
+    assert isinstance(type_definition, ArrayDefinition)
+    assert type_definition.length == 3
+    assert isinstance(type_definition.value_type, primitive._type)
+
+
+@pytest.mark.parametrize("type_str", BASE_TYPES)
+def test_base_types_as_multidimensional_arrays(namespace, type_str):
+    primitive = get_primitive_types()[type_str]
+
+    with namespace.enter_builtin_scope():
+        type_definition = get_type_from_abi({"type": f"{type_str}[3][5]"})
+
+    assert isinstance(type_definition, ArrayDefinition)
+    assert type_definition.length == 5
+    assert isinstance(type_definition.value_type, ArrayDefinition)
+    assert type_definition.value_type.length == 3
+    assert isinstance(type_definition.value_type.value_type, primitive._type)
+
+
+@pytest.mark.parametrize("idx", ["0", "-1", "0x00", "'1'", "foo", "[1]", "(1,)"])
+def test_invalid_index(namespace, idx):
+    with namespace.enter_builtin_scope():
+        with pytest.raises(UnknownType):
+            get_type_from_abi({"type": f"int128[{idx}]"})