feat[lang]: allow hex literals for unsigned integer types

tests/functional/codegen/types/numbers/test_constants.py

@@ -5,7 +5,7 @@
 from tests.utils import ZERO_ADDRESS, decimal_to_int
 from vyper.compiler import compile_code
 from vyper.exceptions import TypeMismatch
-from vyper.utils import MemoryPositions
+from vyper.utils import MemoryPositions, hex_to_int
 
 
 def search_for_sublist(ir, sublist):
@@ -244,3 +244,18 @@ def contains(a: int128) -> bool:
     assert c.contains(44) is True
     assert c.contains(33) is True
     assert c.contains(3) is False
+
+
+def test_constant_hex_int(get_contract):
+    test_value = "0xfa"
+    code = f"""
+X: constant(uint8) = {test_value}
+@external
+def test() -> uint8:
+    y: uint8 = X
+    return y
+    """
+
+    c = get_contract(code)
+
+    assert c.test() == hex_to_int(test_value)

tests/functional/codegen/types/numbers/test_unsigned_ints.py

@@ -210,7 +210,8 @@
 
 
 @pytest.mark.parametrize("typ", types)
-def test_uint_literal(get_contract, typ):
+@pytest.mark.parametrize("is_hex_int", [True, False])
+def test_uint_literal(get_contract, typ, is_hex_int):
     lo, hi = typ.ast_bounds
 
     good_cases = [0, 1, 2, 3, hi // 2 - 1, hi // 2, hi // 2 + 1, hi - 1, hi]
@@ -222,11 +223,21 @@
     return o
     """
 
+    def _to_hex_int(v):
+        n_nibbles = typ.bits // 4
+        return "0x" + hex(v)[2:].rjust(n_nibbles, "0")
+
     for val in good_cases:
-        c = get_contract(code_template.format(typ=typ, val=val))
+        input_val = val
+        if is_hex_int:
+            n_nibbles = typ.bits // 4
+            input_val = "0x" + hex(val)[2:].rjust(n_nibbles, "0")
+        c = get_contract(code_template.format(typ=typ, val=input_val))
         assert c.test() == val
 
     for val in bad_cases:
+        if is_hex_int:
+            return
         exc = (
             TypeMismatch
             if SizeLimits.MIN_INT256 <= val <= SizeLimits.MAX_UINT256

vyper/ast/nodes.py

@@ -31,6 +31,7 @@
     SizeLimits,
     annotate_source_code,
     evm_div,
+    hex_to_int,
     quantize,
     sha256sum,
 )
@@ -883,6 +884,13 @@ def bytes_value(self):
         """
         return bytes.fromhex(self.value.removeprefix("0x"))
 
+    @property
+    def int_value(self):
+        """
+        This value as integer
+        """
+        return hex_to_int(self.value)
+
 
 class Str(Constant):
     __slots__ = ()

vyper/ast/nodes.pyi

@@ -120,6 +120,8 @@ class Decimal(Num): ...
 class Hex(Num):
     @property
     def n_bytes(self): ...
+    @property
+    def int_value(self): ...
 
 class Str(Constant): ...
 class Bytes(Constant): ...

vyper/codegen/expr.py

@@ -16,6 +16,7 @@
     is_array_like,
     is_bytes_m_type,
     is_flag_type,
+    is_integer_type,
     is_numeric_type,
     is_tuple_like,
     make_setter,
@@ -133,6 +134,12 @@ def parse_Hex(self):
 
             return IRnode.from_list(val, typ=t)
 
+        elif is_integer_type(t):
+            assert not t.is_signed
+
+            val = self.expr.int_value
+            return IRnode.from_list(val, typ=t)
+
     # String literals
     def parse_Str(self):
         bytez, bytez_length = string_to_bytes(self.expr.value)

vyper/semantics/types/primitives.py

@@ -138,9 +138,14 @@ def is_signed(self) -> bool:
     def validate_literal(self, node: vy_ast.Constant) -> None:
         super().validate_literal(node)
         lower, upper = self.ast_bounds
-        if node.value < lower:
+
+        value = node.value
+        if isinstance(node, vy_ast.Hex):
+            value = node.int_value
+
+        if value < lower:
             raise OverflowException(f"Value is below lower bound for given type ({lower})", node)
-        if node.value > upper:
+        if value > upper:
             raise OverflowException(f"Value exceeds upper bound for given type ({upper})", node)
 
     def validate_numeric_op(
@@ -242,7 +247,7 @@ class IntegerT(NumericT):
 
     typeclass = "integer"
 
-    _valid_literal = (vy_ast.Int,)
+    _valid_literal = (vy_ast.Hex, vy_ast.Int)
     _equality_attrs = ("is_signed", "bits")
 
     ast_type = int