Allow decimal/binary/octal u256 literals (#7043)

## Description

This PR removes the constraint on `u256` literals being only expressed
in hexadecimal.
The constraint has been removed and the code slightly refactored to
remove the unnecessary `radix` variable in the `lex_int_lit` function in
`token.rs`.
The corresponding error `LexErrorKind::U256NotInHex` has been removed
from the codebasen as well as the `should_fail` test looking to raise
this error.

The u256 testing suite has been augmented with additional tests to make
sure we can express u256 literals in decimal, binary and octal.

Closes #5456 

## Checklist

- [x] I have linked to any relevant issues.
- [x] I have commented my code, particularly in hard-to-understand
areas.
- [ ] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [ ] If my change requires substantial documentation changes, I have
[requested support from the DevRel
team](https://github.com/FuelLabs/devrel-requests/issues/new/choose)
- [x] I have added tests that prove my fix is effective or that my
feature works.
- [ ] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [x] I have requested a review from the relevant team or maintainers.

---------

Co-authored-by: IGI-111 <igi-111@protonmail.com>

Author: saimeunt

sway-error/src/lex_error.rs

@@ -59,8 +59,6 @@ pub enum LexErrorKind {
     UnicodeTextDirInLiteral { position: usize, character: char },
     #[error("invalid escape code")]
     InvalidEscapeCode { position: usize },
-    #[error("invalid u256. Only hex literals are supported")]
-    U256NotInHex,
 }
 
 impl Spanned for LexError {

sway-parse/src/token.rs

@@ -655,7 +655,7 @@ fn lex_int_lit(
         let end_opt = parse_digits(&mut big_uint, l, 10);
         (big_uint, end_opt)
     };
-    let (radix, (big_uint, end_opt)) = if digit == 0 {
+    let (big_uint, end_opt) = if digit == 0 {
         let prefixed_int_lit = |l: &mut Lexer<'_>, radix| {
             let _ = l.stream.next();
             let d = l.stream.next();
@@ -679,32 +679,19 @@ fn lex_int_lit(
         };
 
         match l.stream.peek() {
-            Some((_, 'x')) => (16, prefixed_int_lit(l, 16)?),
-            Some((_, 'o')) => (8, prefixed_int_lit(l, 8)?),
-            Some((_, 'b')) => (2, prefixed_int_lit(l, 2)?),
-            Some((_, '_' | '0'..='9')) => (10, decimal_int_lit(l, 0)),
-            Some(&(next_index, _)) => (10, (BigUint::from(0u32), Some(next_index))),
-            None => (10, (BigUint::from(0u32), None)),
+            Some((_, 'x')) => prefixed_int_lit(l, 16)?,
+            Some((_, 'o')) => prefixed_int_lit(l, 8)?,
+            Some((_, 'b')) => prefixed_int_lit(l, 2)?,
+            Some((_, '_' | '0'..='9')) => decimal_int_lit(l, 0),
+            Some(&(next_index, _)) => (BigUint::from(0u32), Some(next_index)),
+            None => (BigUint::from(0u32), None),
         }
     } else {
-        (10, decimal_int_lit(l, digit))
+        decimal_int_lit(l, digit)
     };
 
     let ty_opt = lex_int_ty_opt(l)?;
 
-    // Only accepts u256 literals in hex form
-    if let Some((LitIntType::U256, span)) = &ty_opt {
-        if radix != 16 {
-            return Err(error(
-                l.handler,
-                LexError {
-                    kind: LexErrorKind::U256NotInHex,
-                    span: span.clone(),
-                },
-            ));
-        }
-    }
-
     let literal = Literal::Int(LitInt {
         span: span(l, index, end_opt.unwrap_or(l.src.len())),
         parsed: big_uint,

test/src/e2e_vm_tests/test_programs/should_fail/u256/u256_only_hex_literal/Forc.lock

@@ -1,8 +1,23 @@
 library; 
 
-// returns 3
+// returns 32
+fn hex_literals() -> u256 {
+    0x10u256 + 0x10u256
+}
+
+// returns 32
+fn oct_literals() -> u256 {
+    0o20u256 + 0o20u256
+}
+
+// returns 32
+fn bin_literals() -> u256 {
+    0b0001_0000u256 + 0b0001_0000u256
+}
+
+// returns 32
 fn literals() -> u256 {
-    0x0000000000000000000000000000000000000000000000000000000000000001u256 + 0x0000000000000000000000000000000000000000000000000000000000000002u256
+    16u256 + 16u256
 }
 
 // returns 1
@@ -117,7 +132,13 @@ fn comparison_operators() -> u256 {
 
 #[test]
 fn should_be_able_to_use_literals() {
-    let result = 0x0000000000000000000000000000000000000000000000000000000000000003u256;
+    let hex_result = 0x20u256;
+    assert_eq(hex_literals(), hex_result);
+    let oct_result = 0o40u256;
+    assert_eq(oct_literals(), oct_result);
+    let bin_result = 0b0010_0000u256;
+    assert_eq(bin_literals(), bin_result);
+    let result = 32u256;
     assert_eq(literals(), result);
 }