feat[lang]: infer expected types

tests/functional/builtins/folding/test_bitwise.py

@@ -4,7 +4,7 @@
 
 from tests.utils import parse_and_fold
 from vyper.exceptions import OverflowException, TypeMismatch
-from vyper.semantics.analysis.utils import validate_expected_type
+from vyper.semantics.analysis.utils import infer_type
 from vyper.semantics.types.shortcuts import INT256_T, UINT256_T
 from vyper.utils import unsigned_to_signed
 
@@ -55,7 +55,7 @@ def foo(a: uint256, b: uint256) -> uint256:
         # force bounds check, no-op because validate_numeric_bounds
         # already does this, but leave in for hygiene (in case
         # more types are added).
-        validate_expected_type(new_node, UINT256_T)
+        _ = infer_type(new_node, UINT256_T)
     # compile time behavior does not match runtime behavior.
     # compile-time will throw on OOB, runtime will wrap.
     except OverflowException:  # here: check the wrapped value matches runtime
@@ -82,7 +82,7 @@ def foo(a: int256, b: uint256) -> int256:
         vyper_ast = parse_and_fold(f"{a} {op} {b}")
         old_node = vyper_ast.body[0].value
         new_node = old_node.get_folded_value()
-        validate_expected_type(new_node, INT256_T)  # force bounds check
+        _ = infer_type(new_node, INT256_T)  # force bounds check
     # compile time behavior does not match runtime behavior.
     # compile-time will throw on OOB, runtime will wrap.
     except (TypeMismatch, OverflowException):

vyper/abi_types.py

@@ -154,7 +154,7 @@ def is_complex_type(self):
 
 class ABI_Bytes(ABIType):
     def __init__(self, bytes_bound):
-        if not bytes_bound >= 0:
+        if bytes_bound is not None and not bytes_bound >= 0:
             raise InvalidABIType("Negative bytes_bound provided to ABI_Bytes")
 
         self.bytes_bound = bytes_bound

vyper/builtins/_convert.py

@@ -431,7 +431,8 @@ def _cast_bytestring(expr, arg, out_typ):
         _FAIL(arg.typ, out_typ, expr)
 
     ret = ["seq"]
-    if out_typ.maxlen < arg.typ.maxlen:
+    assert out_typ.maxlen is not None
+    if arg.typ.maxlen is None or out_typ.maxlen < arg.typ.maxlen:
         ret.append(["assert", ["le", get_bytearray_length(arg), out_typ.maxlen]])
     ret.append(arg)
     # NOTE: this is a pointer cast

vyper/builtins/_signatures.py

@@ -7,11 +7,7 @@
 from vyper.codegen.ir_node import IRnode
 from vyper.exceptions import CompilerPanic, TypeMismatch, UnfoldableNode
 from vyper.semantics.analysis.base import Modifiability
-from vyper.semantics.analysis.utils import (
-    check_modifiability,
-    get_exact_type_from_node,
-    validate_expected_type,
-)
+from vyper.semantics.analysis.utils import check_modifiability, get_exact_type_from_node, infer_type
 from vyper.semantics.types import TYPE_T, KwargSettings, VyperType
 from vyper.semantics.types.utils import type_from_annotation
 
@@ -101,7 +97,7 @@
             # for its side effects (will throw if is not a type)
             type_from_annotation(arg)
         else:
-            validate_expected_type(arg, expected_type)
+            infer_type(arg, expected_type)
 
     def _validate_arg_types(self, node: vy_ast.Call) -> None:
         num_args = len(self._inputs)  # the number of args the signature indicates

vyper/builtins/functions.py

@@ -58,7 +58,7 @@
     get_common_types,
     get_exact_type_from_node,
     get_possible_types_from_node,
-    validate_expected_type,
+    infer_type,
 )
 from vyper.semantics.types import (
     TYPE_T,
@@ -207,12 +207,14 @@ def infer_arg_types(self, node, expected_return_typ=None):
         target_type = type_from_annotation(node.args[1])
         value_types = get_possible_types_from_node(node.args[0])
 
-        # For `convert` of integer literals, we need to match type inference rules in
-        # convert.py codegen routines.
+        # For `convert` of integer literals, we need to match type inference
+        # rules in convert.py codegen routines.
         # TODO: This can probably be removed once constant folding for `convert` is implemented
         if len(value_types) > 1 and all(isinstance(v, IntegerT) for v in value_types):
-            # Get the smallest (and unsigned if available) type for non-integer target types
-            # (note this is different from the ordering returned by `get_possible_types_from_node`)
+            # Get the smallest (and unsigned if available) type for
+            # non-integer target types
+            # (note this is different from the ordering returned by
+            # `get_possible_types_from_node`)
             if not isinstance(target_type, IntegerT):
                 value_types = sorted(value_types, key=lambda v: (v.is_signed, v.bits), reverse=True)
             else:
@@ -223,7 +225,10 @@ def infer_arg_types(self, node, expected_return_typ=None):
 
         # block conversions between same type
         if target_type.compare_type(value_type):
-            raise InvalidType(f"Value and target type are both '{target_type}'", node)
+            raise InvalidType(
+                f"Value and target type are both `{target_type}`",
+                hint="try removing the call to `convert()`",
+            )
 
         return [value_type, TYPE_T(target_type)]
 
@@ -296,11 +301,6 @@ class Slice(BuiltinFunctionT):
     def fetch_call_return(self, node):
         arg_type, _, _ = self.infer_arg_types(node)
 
-        if isinstance(arg_type, StringT):
-            return_type = StringT()
-        else:
-            return_type = BytesT()
-
         # validate start and length are in bounds
 
         arg = node.args[0]
@@ -329,20 +329,14 @@ def fetch_call_return(self, node):
                 if length_literal is not None and start_literal + length_literal > arg_type.length:
                     raise ArgumentException(f"slice out of bounds for {arg_type}", node)
 
-        # we know the length statically
+        return_cls = arg_type.__class__
         if length_literal is not None:
-            return_type.set_length(length_literal)
+            return_type = return_cls(length_literal)
         else:
-            return_type.set_min_length(arg_type.length)
+            return_type = return_cls(arg_type.length)
 
         return return_type
 
-    def infer_arg_types(self, node, expected_return_typ=None):
-        self._validate_arg_types(node)
-        # return a concrete type for `b`
-        b_type = get_possible_types_from_node(node.args[0]).pop()
-        return [b_type, self._inputs[1][1], self._inputs[2][1]]
-
     @process_inputs
     def build_IR(self, expr, args, kwargs, context):
         src, start, length = args
@@ -498,12 +492,8 @@ def fetch_call_return(self, node):
         for arg_t in arg_types:
             length += arg_t.length
 
-        if isinstance(arg_types[0], (StringT)):
-            return_type = StringT()
-        else:
-            return_type = BytesT()
-        return_type.set_length(length)
-        return return_type
+        return_type_cls = arg_types[0].__class__
+        return return_type_cls(length)
 
     def infer_arg_types(self, node, expected_return_typ=None):
         if len(node.args) < 2:
@@ -515,8 +505,7 @@ def infer_arg_types(self, node, expected_return_typ=None):
         ret = []
         prev_typeclass = None
         for arg in node.args:
-            validate_expected_type(arg, (BytesT.any(), StringT.any(), BytesM_T.any()))
-            arg_t = get_possible_types_from_node(arg).pop()
+            arg_t = infer_type(arg, (BytesT.any(), StringT.any(), BytesM_T.any()))
             current_typeclass = "String" if isinstance(arg_t, StringT) else "Bytes"
             if prev_typeclass and current_typeclass != prev_typeclass:
                 raise TypeMismatch(
@@ -855,7 +844,7 @@ def infer_kwarg_types(self, node):
                     "Output type must be one of integer, bytes32 or address", node.keywords[0].value
                 )
             output_typedef = TYPE_T(output_type)
-            node.keywords[0].value._metadata["type"] = output_typedef
+            # node.keywords[0].value._metadata["type"] = output_typedef
         else:
             output_typedef = TYPE_T(BYTES32_T)
 
@@ -1039,8 +1028,7 @@ def fetch_call_return(self, node):
             raise
 
         if outsize.value:
-            return_type = BytesT()
-            return_type.set_min_length(outsize.value)
+            return_type = BytesT(outsize.value)
 
             if revert_on_failure:
                 return return_type
@@ -2355,9 +2343,8 @@ def infer_kwarg_types(self, node):
         ret = {}
         for kwarg in node.keywords:
             kwarg_name = kwarg.arg
-            validate_expected_type(kwarg.value, self._kwargs[kwarg_name].typ)
+            typ = infer_type(kwarg.value, self._kwargs[kwarg_name].typ)
 
-            typ = get_exact_type_from_node(kwarg.value)
             if kwarg_name == "method_id" and isinstance(typ, BytesT):
                 if typ.length != 4:
                     raise InvalidLiteral("method_id must be exactly 4 bytes!", kwarg.value)
@@ -2392,9 +2379,7 @@ def fetch_call_return(self, node):
             # the output includes 4 bytes for the method_id.
             maxlen += 4
 
-        ret = BytesT()
-        ret.set_length(maxlen)
-        return ret
+        return BytesT(maxlen)
 
     @staticmethod
     def _parse_method_id(method_id_literal):

vyper/codegen/core.py

@@ -737,7 +737,11 @@ def dummy_node_for_type(typ):
 
 
 def _check_assign_bytes(left, right):
-    if right.typ.maxlen > left.typ.maxlen:  # pragma: nocover
+    if (
+        left.typ.maxlen is not None
+        and right.typ.maxlen is not None
+        and right.typ.maxlen > left.typ.maxlen
+    ):  # pragma: nocover
         raise TypeMismatch(f"Cannot cast from {right.typ} to {left.typ}")
 
     # stricter check for zeroing a byte array.

vyper/codegen/expr.py

@@ -733,26 +733,27 @@ def parse_Call(self):
 
         return self_call.ir_for_self_call(self.expr, self.context)
 
-    @classmethod
-    def handle_external_call(cls, expr, context):
+    def handle_external_call(self):
         # TODO fix cyclic import
         from vyper.builtins._signatures import BuiltinFunctionT
 
-        call_node = expr.value
+        call_node = self.expr.value
         assert isinstance(call_node, vy_ast.Call)
 
         func_t = call_node.func._metadata["type"]
 
         if isinstance(func_t, BuiltinFunctionT):
-            return func_t.build_IR(call_node, context)
+            return func_t.build_IR(call_node, self.context)
 
-        return external_call.ir_for_external_call(call_node, context)
+        return external_call.ir_for_external_call(
+            call_node, self.context, discard_output=self.is_stmt
+        )
 
     def parse_ExtCall(self):
-        return self.handle_external_call(self.expr, self.context)
+        return self.handle_external_call()
 
     def parse_StaticCall(self):
-        return self.handle_external_call(self.expr, self.context)
+        return self.handle_external_call()
 
     def parse_List(self):
         typ = self.expr._metadata["type"]

vyper/codegen/external_call.py

@@ -20,7 +20,7 @@
 from vyper.codegen.ir_node import Encoding, IRnode
 from vyper.evm.address_space import MEMORY
 from vyper.exceptions import TypeCheckFailure
-from vyper.semantics.types import InterfaceT, TupleT
+from vyper.semantics.types import VOID_TYPE, InterfaceT, TupleT
 from vyper.semantics.types.function import StateMutability
 
 
@@ -32,7 +32,7 @@ class _CallKwargs:
     default_return_value: IRnode
 
 
-def _pack_arguments(fn_type, args, context):
+def _pack_arguments(fn_type, out_type, args, context):
     # abi encoding just treats all args as a big tuple
     args_tuple_t = TupleT([x.typ for x in args])
     args_as_tuple = IRnode.from_list(["multi"] + [x for x in args], typ=args_tuple_t)
@@ -42,12 +42,12 @@ def _pack_arguments(fn_type, args, context):
     dst_tuple_t = TupleT(fn_type.argument_types[: len(args)])
     check_assign(dummy_node_for_type(dst_tuple_t), args_as_tuple)
 
-    if fn_type.return_type is not None:
-        return_abi_t = calculate_type_for_external_return(fn_type.return_type).abi_type
+    if out_type is not None:
+        out_abi_t = calculate_type_for_external_return(out_type).abi_type
 
         # we use the same buffer for args and returndata,
         # so allocate enough space here for the returndata too.
-        buflen = max(args_abi_t.size_bound(), return_abi_t.size_bound())
+        buflen = max(args_abi_t.size_bound(), out_abi_t.size_bound())
     else:
         buflen = args_abi_t.size_bound()
 
@@ -78,13 +78,11 @@ def _pack_arguments(fn_type, args, context):
     return buf, pack_args, args_ofst, args_len
 
 
-def _unpack_returndata(buf, fn_type, call_kwargs, contract_address, context, expr):
-    return_t = fn_type.return_type
-
-    if return_t is None:
+def _unpack_returndata(buf, out_type, call_kwargs, contract_address, context, expr):
+    if out_type is None:
         return ["pass"], 0, 0
 
-    wrapped_return_t = calculate_type_for_external_return(return_t)
+    wrapped_return_t = calculate_type_for_external_return(out_type)
 
     abi_return_t = wrapped_return_t.abi_type
 
@@ -188,9 +186,18 @@ def _extcodesize_check(address):
     return IRnode.from_list(["assert", ["extcodesize", address]], error_msg="extcodesize is zero")
 
 
-def _external_call_helper(contract_address, args_ir, call_kwargs, call_expr, context):
+def _external_call_helper(
+    contract_address, args_ir, call_kwargs, call_expr, context, discard_output
+):
     fn_type = call_expr.func._metadata["type"]
 
+    out_type = call_expr._metadata["type"]
+    if out_type is VOID_TYPE or discard_output:
+        assert (out_type is VOID_TYPE) == (fn_type.return_type is None), out_type
+        out_type = None  # makes downstream logic cleaner
+    else:
+        check_assign(dummy_node_for_type(out_type), dummy_node_for_type(fn_type.return_type))
+
     # sanity check
     assert fn_type.n_positional_args <= len(args_ir) <= fn_type.n_total_args
 
@@ -201,10 +208,10 @@ def _external_call_helper(contract_address, args_ir, call_kwargs, call_expr, con
     # a duplicate label exception will get thrown during assembly.
     ret.append(eval_once_check(_freshname(call_expr.node_source_code)))
 
-    buf, arg_packer, args_ofst, args_len = _pack_arguments(fn_type, args_ir, context)
+    buf, arg_packer, args_ofst, args_len = _pack_arguments(fn_type, out_type, args_ir, context)
 
     ret_unpacker, ret_ofst, ret_len = _unpack_returndata(
-        buf, fn_type, call_kwargs, contract_address, context, call_expr
+        buf, out_type, call_kwargs, contract_address, context, call_expr
     )
 
     ret += arg_packer
@@ -232,14 +239,13 @@ def _external_call_helper(contract_address, args_ir, call_kwargs, call_expr, con
 
     ret.append(check_external_call(call_op))
 
-    return_t = fn_type.return_type
-    if return_t is not None:
+    if out_type is not None:
         ret.append(ret_unpacker)
 
-    return IRnode.from_list(ret, typ=return_t, location=MEMORY)
+    return IRnode.from_list(ret, typ=out_type, location=MEMORY)
 
 
-def ir_for_external_call(call_expr, context):
+def ir_for_external_call(call_expr, context, discard_output):
     from vyper.codegen.expr import Expr  # TODO rethink this circular import
 
     contract_address = Expr.parse_value_expr(call_expr.func.value, context)
@@ -249,5 +255,7 @@ def ir_for_external_call(call_expr, context):
 
     with contract_address.cache_when_complex("external_contract") as (b1, contract_address):
         return b1.resolve(
-            _external_call_helper(contract_address, args_ir, call_kwargs, call_expr, context)
+            _external_call_helper(
+                contract_address, args_ir, call_kwargs, call_expr, context, discard_output
+            )
         )