feat[codegen]: changed the convert from bytes

tests/functional/builtins/codegen/test_convert.py

@@ -426,6 +426,48 @@ def _vyper_literal(val, typ):
     return str(val)
 
 
+def test_bytes_to_int_different_sizes(get_contract):
+    code = r"""
+@external
+def foo() -> int16:
+    return convert(b'\xff', int16)
+    """
+
+    c = get_contract(code)
+    assert c.foo() == -1
+
+    code = r"""
+FOO: constant(Bytes[2]) = b'\xff'
+
+@external
+def foo() -> int16:
+    return convert(FOO, int16)
+    """
+
+    c = get_contract(code)
+    assert c.foo() == 255
+
+
+def test_bytes_to_int_different_sizes_runtime(get_contract):
+    code = """
+@external
+def foo(x: Bytes[1]) -> int16:
+    return convert(x, int16)
+    """
+
+    c = get_contract(code)
+    assert c.foo(b"\xff") == -1
+
+    code = """
+@external
+def foo(x: Bytes[2]) -> int16:
+    return convert(x, int16)
+    """
+
+    c = get_contract(code)
+    assert c.foo(b"\xff") == 255
+
+
 @pytest.mark.parametrize("i_typ,o_typ,val", generate_passing_cases())
 @pytest.mark.fuzzing
 def test_convert_passing(get_contract, assert_compile_failed, i_typ, o_typ, val):

vyper/builtins/_convert.py

@@ -56,7 +56,7 @@ def _FAIL(ityp, otyp, source_expr=None):
 def _input_types(*allowed_types):
     def decorator(f):
         @functools.wraps(f)
-        def check_input_type(expr, arg, out_typ):
+        def check_input_type(expr, arg, in_typ, out_typ):
             # convert arg to out_typ.
             # (expr is the AST corresponding to `arg`)
             ok = isinstance(arg.typ, allowed_types)
@@ -69,34 +69,41 @@ def check_input_type(expr, arg, out_typ):
             if arg.typ == out_typ and arg.typ not in (UINT256_T, INT256_T):
                 raise InvalidType(f"value and target are both {out_typ}", expr)
 
-            return f(expr, arg, out_typ)
+            return f(expr, arg, in_typ, out_typ)
 
         return check_input_type
 
     return decorator
 
 
-def _bytes_to_num(arg, out_typ, signed):
+def _bytes_to_num(arg, in_typ, out_typ, signed):
     # converting a bytestring to a number:
     # bytestring and bytes_m are right-padded with zeroes, int is left-padded.
     # convert by shr or sar the number of zero bytes (converted to bits)
     # e.g. "abcd000000000000" -> bitcast(000000000000abcd, output_type)
 
-    if isinstance(arg.typ, _BytestringT):
-        if not is_bounded_length(arg.typ.maxlen):
+    if isinstance(in_typ, _BytestringT):
+        if not is_bounded_length(in_typ.maxlen):
             raise CodegenPanic("convert: unbounded bytestring type")
         _len = get_bytearray_length(arg)
+        assert isinstance(in_typ, _BytestringT)
+        maxlen = in_typ.maxlen
+        assert isinstance(maxlen, int)
+
         arg = LOAD(bytes_data_ptr(arg))
-        num_zero_bits = ["mul", 8, ["sub", 32, _len]]
-    elif is_bytes_m_type(arg.typ):
-        num_zero_bits = 8 * (32 - arg.typ.m)
+        runtime_compile_diff = ["sub", maxlen, _len]
+        val = shr(["mul", runtime_compile_diff, 8], arg)
+        num_zero_bits = ["mul", 8, ["sub", 32, maxlen]]
+    elif is_bytes_m_type(in_typ):
+        num_zero_bits = 8 * (32 - in_typ.m)
+        val = arg
     else:  # pragma: nocover
         raise CompilerPanic("unreachable")
 
     if signed:
-        ret = sar(num_zero_bits, arg)
+        ret = sar(num_zero_bits, val)
     else:
-        ret = shr(num_zero_bits, arg)
+        ret = shr(num_zero_bits, val)
 
     annotation = (f"__intrinsic__byte_array_to_num({out_typ})",)
     return IRnode.from_list(ret, annotation=annotation)
@@ -213,7 +220,7 @@ def _signextend(expr, val, arg_typ):
         assert len(expr.value[2:]) // 2 == arg_typ.m
         n_bits = arg_typ.m_bits
     else:
-        assert len(expr.value) == arg_typ.maxlen
+        assert len(expr.value) <= arg_typ.maxlen
         n_bits = arg_typ.maxlen * 8
 
     return unsigned_to_signed(val, n_bits)
@@ -269,12 +276,12 @@ def _literal_decimal(expr, arg_typ, out_typ):
 
 # any base type or bytes/string
 @_input_types(IntegerT, DecimalT, BytesM_T, AddressT, BoolT, BytesT, StringT)
-def to_bool(expr, arg, out_typ):
+def to_bool(expr, arg, in_typ, out_typ):
     _check_bytes(expr, arg, out_typ, 32)  # should we restrict to Bytes[1]?
 
     if isinstance(arg.typ, _BytestringT):
         # no clamp. checks for any nonzero bytes.
-        arg = _bytes_to_num(arg, out_typ, signed=False)
+        arg = _bytes_to_num(arg, in_typ, out_typ, signed=False)
 
     # NOTE: for decimal, the behavior is x != 0.0,
     # (we do not issue an `sdiv DECIMAL_DIVISOR`)
@@ -283,27 +290,27 @@ def to_bool(expr, arg, out_typ):
 
 
 @_input_types(IntegerT, DecimalT, BytesM_T, AddressT, BoolT, FlagT, BytesT)
-def to_int(expr, arg, out_typ):
-    return _to_int(expr, arg, out_typ)
+def to_int(expr, arg, in_typ, out_typ):
+    return _to_int(expr, arg, in_typ, out_typ)
 
 
 # an internal version of to_int without input validation
-def _to_int(expr, arg, out_typ):
+def _to_int(expr, arg, in_typ, out_typ):
     assert out_typ.bits % 8 == 0
     _check_bytes(expr, arg, out_typ, 32)
 
     if isinstance(expr, vy_ast.Constant):
-        return _literal_int(expr, arg.typ, out_typ)
+        return _literal_int(expr, in_typ, out_typ)
 
     elif isinstance(arg.typ, BytesT):
         arg_typ = arg.typ
-        arg = _bytes_to_num(arg, out_typ, signed=out_typ.is_signed)
+        arg = _bytes_to_num(arg, in_typ, out_typ, signed=out_typ.is_signed)
         if arg_typ.maxlen * 8 > out_typ.bits:
             arg = int_clamp(arg, out_typ.bits, signed=out_typ.is_signed)
 
     elif is_bytes_m_type(arg.typ):
         arg_typ = arg.typ
-        arg = _bytes_to_num(arg, out_typ, signed=out_typ.is_signed)
+        arg = _bytes_to_num(arg, in_typ, out_typ, signed=out_typ.is_signed)
         if arg_typ.m_bits > out_typ.bits:
             arg = int_clamp(arg, out_typ.bits, signed=out_typ.is_signed)
 
@@ -332,15 +339,15 @@ def _to_int(expr, arg, out_typ):
 
 
 @_input_types(IntegerT, BoolT, BytesM_T, BytesT)
-def to_decimal(expr, arg, out_typ):
+def to_decimal(expr, arg, in_typ, out_typ):
     _check_bytes(expr, arg, out_typ, 32)
 
     if isinstance(expr, vy_ast.Constant):
         return _literal_decimal(expr, arg.typ, out_typ)
 
     if isinstance(arg.typ, BytesT):
         arg_typ = arg.typ
-        arg = _bytes_to_num(arg, out_typ, signed=True)
+        arg = _bytes_to_num(arg, in_typ, out_typ, signed=True)
         if arg_typ.maxlen * 8 > 168:
             arg = IRnode.from_list(arg, typ=out_typ)
             arg = clamp_basetype(arg)
@@ -349,7 +356,7 @@ def to_decimal(expr, arg, out_typ):
 
     elif is_bytes_m_type(arg.typ):
         arg_typ = arg.typ
-        arg = _bytes_to_num(arg, out_typ, signed=True)
+        arg = _bytes_to_num(arg, in_typ, out_typ, signed=True)
         if arg_typ.m_bits > 168:
             arg = IRnode.from_list(arg, typ=out_typ)
             arg = clamp_basetype(arg)
@@ -369,7 +376,7 @@ def to_decimal(expr, arg, out_typ):
 
 
 @_input_types(IntegerT, DecimalT, BytesM_T, AddressT, BytesT, BoolT)
-def to_bytes_m(expr, arg, out_typ):
+def to_bytes_m(expr, arg, in_typ, out_typ):
     _check_bytes(expr, arg, out_typ, max_bytes_allowed=out_typ.m)
 
     if isinstance(arg.typ, BytesT):
@@ -417,13 +424,13 @@ def to_bytes_m(expr, arg, out_typ):
 
 
 @_input_types(BytesM_T, IntegerT, BytesT)
-def to_address(expr, arg, out_typ):
+def to_address(expr, arg, in_typ, out_typ):
     # question: should this be allowed?
     if is_integer_type(arg.typ):
         if arg.typ.is_signed:
             _FAIL(arg.typ, out_typ, expr)
 
-    ret = _to_int(expr, arg, UINT160_T)
+    ret = _to_int(expr, arg, in_typ, UINT160_T)
     return IRnode.from_list(ret, out_typ)
 
 
@@ -445,17 +452,17 @@ def _cast_bytestring(expr, arg, out_typ):
 
 # question: should we allow bytesM -> String?
 @_input_types(BytesT, StringT)
-def to_string(expr, arg, out_typ):
+def to_string(expr, arg, in_typ, out_typ):
     return _cast_bytestring(expr, arg, out_typ)
 
 
 @_input_types(StringT, BytesT)
-def to_bytes(expr, arg, out_typ):
+def to_bytes(expr, arg, in_typ, out_typ):
     return _cast_bytestring(expr, arg, out_typ)
 
 
 @_input_types(IntegerT)
-def to_flag(expr, arg, out_typ):
+def to_flag(expr, arg, in_typ, out_typ):
     if arg.typ != UINT256_T:
         _FAIL(arg.typ, out_typ, expr)
 
@@ -468,6 +475,7 @@ def to_flag(expr, arg, out_typ):
 def convert(expr, context):
     assert len(expr.args) == 2, "bad typecheck: convert"
 
+    in_typ = expr.args[0]._metadata["type"]
     arg_ast = expr.args[0].reduced()
     arg = Expr(arg_ast, context).ir_node
     original_arg = arg
@@ -478,21 +486,21 @@ def convert(expr, context):
         arg = unwrap_location(arg)
     with arg.cache_when_complex("arg") as (b, arg):
         if out_typ == BoolT():
-            ret = to_bool(arg_ast, arg, out_typ)
+            ret = to_bool(arg_ast, arg, in_typ, out_typ)
         elif out_typ == AddressT():
-            ret = to_address(arg_ast, arg, out_typ)
+            ret = to_address(arg_ast, arg, in_typ, out_typ)
         elif is_flag_type(out_typ):
-            ret = to_flag(arg_ast, arg, out_typ)
+            ret = to_flag(arg_ast, arg, in_typ, out_typ)
         elif is_integer_type(out_typ):
-            ret = to_int(arg_ast, arg, out_typ)
+            ret = to_int(arg_ast, arg, in_typ, out_typ)
         elif is_bytes_m_type(out_typ):
-            ret = to_bytes_m(arg_ast, arg, out_typ)
+            ret = to_bytes_m(arg_ast, arg, in_typ, out_typ)
         elif is_decimal_type(out_typ):
-            ret = to_decimal(arg_ast, arg, out_typ)
+            ret = to_decimal(arg_ast, arg, in_typ, out_typ)
         elif isinstance(out_typ, BytesT):
-            ret = to_bytes(arg_ast, arg, out_typ)
+            ret = to_bytes(arg_ast, arg, in_typ, out_typ)
         elif isinstance(out_typ, StringT):
-            ret = to_string(arg_ast, arg, out_typ)
+            ret = to_string(arg_ast, arg, in_typ, out_typ)
         else:
             raise StructureException(f"Conversion to {out_typ} is invalid.", arg_ast)
 

vyper/codegen_venom/builtins/convert.py

@@ -184,11 +184,17 @@ def _to_int(
         data = b.mload(data_ptr)
         # Right-shift to convert left-aligned bytes to right-aligned int
         # num_zero_bits = (32 - len) * 8
-        num_zero_bits = b.mul(b.sub(IRLiteral(32), length), IRLiteral(8))
+
+        assert isinstance(in_t.maxlen, int)
+        runtime_compile_diff = b.sub(in_t.maxlen, length)
+
+        val = b.shr(b.mul(runtime_compile_diff, 8), data)
+
+        num_zero_bits = b.mul(b.sub(IRLiteral(32), in_t.maxlen), IRLiteral(8))
         if out_t.is_signed:
-            val = b.sar(num_zero_bits, data)
+            val = b.sar(num_zero_bits, val)
         else:
-            val = b.shr(num_zero_bits, data)
+            val = b.shr(num_zero_bits, val)
         # Clamp if bytes could exceed output range
         if in_t.maxlen * 8 > out_t.bits:
             val = _int_clamp(val, out_t, ctx)