From 05b25d2127876588cefb746a3e3da48b14f028b1 Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Fri, 28 Feb 2025 09:37:24 -0300 Subject: [PATCH 1/7] some tests to sierra --- src/libfuncs/bool.rs | 103 +++--- src/libfuncs/bounded_int.rs | 185 +++++------ src/libfuncs/box.rs | 55 ++-- src/libfuncs/bytes31.rs | 58 ++-- src/libfuncs/cast.rs | 604 +++++++++++++++++++----------------- src/libfuncs/const.rs | 77 ++++- src/utils.rs | 28 ++ 7 files changed, 615 insertions(+), 495 deletions(-) diff --git a/src/libfuncs/bool.rs b/src/libfuncs/bool.rs index c9ca75bf3..a422e4b0d 100644 --- a/src/libfuncs/bool.rs +++ b/src/libfuncs/bool.rs @@ -209,65 +209,64 @@ pub fn build_bool_to_felt252<'ctx, 'this>( #[cfg(test)] mod test { + use cairo_lang_sierra::extensions::boolean::{ + BoolAndLibfunc, BoolNotLibfunc, BoolOrLibfunc, BoolToFelt252Libfunc, BoolXorLibfunc, + }; + use crate::{ - utils::test::{jit_enum, jit_struct, load_cairo, run_program}, + utils::{ + sierra_gen::SierraGenerator, + test::{jit_enum, jit_struct, run_sierra_program}, + }, values::Value, }; #[test] fn run_not() { - let program = load_cairo!( - use array::ArrayTrait; + let program = { + let sierra_generator = SierraGenerator::::default(); - fn run_test(a: bool) -> bool { - !a - } - ); + sierra_generator.build(&[]) + }; - let result = run_program(&program, "run_test", &[jit_enum!(0, jit_struct!())]).return_value; + let result = run_sierra_program(&program, &[jit_enum!(0, jit_struct!())]).return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_program(&program, "run_test", &[jit_enum!(1, jit_struct!())]).return_value; + let result = run_sierra_program(&program, &[jit_enum!(1, jit_struct!())]).return_value; assert_eq!(result, jit_enum!(0, jit_struct!())); } #[test] fn run_and() { - let program = load_cairo!( - use array::ArrayTrait; + let program = { + let sierra_generator = SierraGenerator::::default(); - fn run_test(a: bool, b: bool) -> bool { - a && b - } - ); + sierra_generator.build(&[]) + }; - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(1, jit_struct!()), jit_enum!(1, jit_struct!())], ) .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(1, jit_struct!()), jit_enum!(0, jit_struct!())], ) .return_value; assert_eq!(result, jit_enum!(0, jit_struct!())); - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(0, jit_struct!()), jit_enum!(1, jit_struct!())], ) .return_value; assert_eq!(result, jit_enum!(0, jit_struct!())); - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(0, jit_struct!()), jit_enum!(0, jit_struct!())], ) .return_value; @@ -276,41 +275,35 @@ mod test { #[test] fn run_xor() { - let program = load_cairo!( - use array::ArrayTrait; + let program = { + let sierra_generator = SierraGenerator::::default(); - fn run_test(a: bool, b: bool) -> bool { - a ^ b - } - ); + sierra_generator.build(&[]) + }; - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(1, jit_struct!()), jit_enum!(1, jit_struct!())], ) .return_value; assert_eq!(result, jit_enum!(0, jit_struct!())); - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(1, jit_struct!()), jit_enum!(0, jit_struct!())], ) .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(0, jit_struct!()), jit_enum!(1, jit_struct!())], ) .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(0, jit_struct!()), jit_enum!(0, jit_struct!())], ) .return_value; @@ -319,41 +312,35 @@ mod test { #[test] fn run_or() { - let program = load_cairo!( - use array::ArrayTrait; + let program = { + let sierra_generator = SierraGenerator::::default(); - fn run_test(a: bool, b: bool) -> bool { - a || b - } - ); + sierra_generator.build(&[]) + }; - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(1, jit_struct!()), jit_enum!(1, jit_struct!())], ) .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(1, jit_struct!()), jit_enum!(0, jit_struct!())], ) .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(0, jit_struct!()), jit_enum!(1, jit_struct!())], ) .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_program( + let result = run_sierra_program( &program, - "run_test", &[jit_enum!(0, jit_struct!()), jit_enum!(0, jit_struct!())], ) .return_value; @@ -362,16 +349,16 @@ mod test { #[test] fn bool_to_felt252() { - let program = load_cairo!( - fn run_test(a: bool) -> felt252 { - bool_to_felt252(a) - } - ); + let program = { + let sierra_generator = SierraGenerator::::default(); + + sierra_generator.build(&[]) + }; - let result = run_program(&program, "run_test", &[jit_enum!(1, jit_struct!())]).return_value; + let result = run_sierra_program(&program, &[jit_enum!(1, jit_struct!())]).return_value; assert_eq!(result, Value::Felt252(1.into())); - let result = run_program(&program, "run_test", &[jit_enum!(0, jit_struct!())]).return_value; + let result = run_sierra_program(&program, &[jit_enum!(0, jit_struct!())]).return_value; assert_eq!(result, Value::Felt252(0.into())); } } diff --git a/src/libfuncs/bounded_int.rs b/src/libfuncs/bounded_int.rs index c50ee5201..c1392785f 100644 --- a/src/libfuncs/bounded_int.rs +++ b/src/libfuncs/bounded_int.rs @@ -817,134 +817,117 @@ fn build_wrap_non_zero<'ctx, 'this>( #[cfg(test)] mod test { + use cairo_lang_sierra::{ + extensions::{ + bounded_int::BoundedIntTrimLibfunc, + int::{ + signed::{Sint16Type, Sint8Type}, + unsigned::Uint32Type, + }, + }, + program::GenericArg, + }; use cairo_vm::Felt252; use crate::{ - context::NativeContext, execution_result::ExecutionResult, executor::JitNativeExecutor, - utils::test::load_cairo, OptLevel, Value, + utils::{ + sierra_gen::SierraGenerator, + test::{jit_struct, run_sierra_program}, + }, + Value, }; #[test] fn test_trim_some_pos_i8() { - let (_, program) = load_cairo!( - use core::internal::{OptionRev, bounded_int::BoundedInt}; - use core::internal::bounded_int; - fn main() -> BoundedInt<-128, 126> { - let num = match bounded_int::trim_max::(1) { - OptionRev::Some(n) => n, - OptionRev::None => 0, - }; - - num - } - ); - let ctx = NativeContext::new(); - let module = ctx.compile(&program, false, None).unwrap(); - let executor = JitNativeExecutor::from_native_module(module, OptLevel::Default).unwrap(); - let ExecutionResult { - remaining_gas: _, - return_value, - builtin_stats: _, - } = executor - .invoke_dynamic(&program.funcs[0].id, &[], None) - .unwrap(); - - let Value::BoundedInt { value, range: _ } = return_value else { + let program_trim = { + let mut generator = SierraGenerator::>::default(); + let i8_ty = generator.push_type_declaration::(&[]).clone(); + + generator.build(&[GenericArg::Type(i8_ty)]) + }; + let Value::Enum { + tag: 1, + value, + debug_name: _, + } = run_sierra_program(&program_trim, &[Value::Sint8(1)]).return_value + else { + panic!("should be OptionRev::Some"); + }; + + let Value::BoundedInt { value, range: _ } = *value else { panic!(); }; + assert_eq!(value, Felt252::from(1_u8)); } #[test] fn test_trim_some_neg_i8() { - let (_, program) = load_cairo!( - use core::internal::{OptionRev, bounded_int::BoundedInt}; - use core::internal::bounded_int; - fn main() -> BoundedInt<-127, 127> { - let num = match bounded_int::trim_min::(1) { - OptionRev::Some(n) => n, - OptionRev::None => 1, - }; - - num - } - ); - let ctx = NativeContext::new(); - let module = ctx.compile(&program, false, None).unwrap(); - let executor = JitNativeExecutor::from_native_module(module, OptLevel::Default).unwrap(); - let ExecutionResult { - remaining_gas: _, - return_value, - builtin_stats: _, - } = executor - .invoke_dynamic(&program.funcs[0].id, &[], None) - .unwrap(); - - let Value::BoundedInt { value, range: _ } = return_value else { + let program_trim = { + let mut generator = SierraGenerator::>::default(); + let i8_ty = generator.push_type_declaration::(&[]).clone(); + + generator.build(&[GenericArg::Type(i8_ty)]) + }; + let Value::Enum { + tag: 1, + value, + debug_name: _, + } = run_sierra_program(&program_trim, &[Value::Sint8(-1)]).return_value + else { + panic!("should be OptionRev::Some"); + }; + + let Value::BoundedInt { value, range: _ } = *value else { panic!(); }; - assert_eq!(value, Felt252::from(1_u8)); + + assert_eq!(value, Felt252::from(-1_i8)); } #[test] fn test_trim_some_u32() { - let (_, program) = load_cairo!( - use core::internal::{OptionRev, bounded_int::BoundedInt}; - use core::internal::bounded_int; - fn main() -> BoundedInt<0, 4294967294> { - let num = match bounded_int::trim_max::(0xfffffffe) { - OptionRev::Some(n) => n, - OptionRev::None => 0, - }; - - num - } - ); - let ctx = NativeContext::new(); - let module = ctx.compile(&program, false, None).unwrap(); - let executor = JitNativeExecutor::from_native_module(module, OptLevel::Default).unwrap(); - let ExecutionResult { - remaining_gas: _, - return_value, - builtin_stats: _, - } = executor - .invoke_dynamic(&program.funcs[0].id, &[], None) - .unwrap(); - - let Value::BoundedInt { value, range: _ } = return_value else { + let program_trim = { + let mut generator = SierraGenerator::>::default(); + let u32_ty = generator.push_type_declaration::(&[]).clone(); + + generator.build(&[GenericArg::Type(u32_ty)]) + }; + + let Value::Enum { + tag: 1, + value, + debug_name: _, + } = run_sierra_program(&program_trim, &[Value::Uint32(0xfffffffe)]).return_value + else { + panic!("should be OptionRev::Some"); + }; + + let Value::BoundedInt { value, range: _ } = *value else { panic!(); }; + assert_eq!(value, Felt252::from(0xfffffffe_u32)); } #[test] fn test_trim_none() { - let (_, program) = load_cairo!( - use core::internal::{OptionRev, bounded_int::BoundedInt}; - use core::internal::bounded_int; - fn main() -> BoundedInt<-32767, 32767> { - let num = match bounded_int::trim_min::(-0x8000) { - OptionRev::Some(n) => n, - OptionRev::None => 0, - }; - - num - } - ); - let ctx = NativeContext::new(); - let module = ctx.compile(&program, false, None).unwrap(); - let executor = JitNativeExecutor::from_native_module(module, OptLevel::Default).unwrap(); - let ExecutionResult { - remaining_gas: _, - return_value, - builtin_stats: _, - } = executor - .invoke_dynamic(&program.funcs[0].id, &[], None) - .unwrap(); - - let Value::BoundedInt { value, range: _ } = return_value else { - panic!(); + let program_trim = { + let mut generator = SierraGenerator::>::default(); + let i16_ty = generator.push_type_declaration::(&[]).clone(); + + generator.build(&[GenericArg::Type(i16_ty)]) }; - assert_eq!(value, Felt252::from(0)); + + let Value::Enum { + tag: 0, + value, + debug_name: _, + } = run_sierra_program(&program_trim, &[Value::Sint16(-0x8000)]).return_value + else { + panic!("should be OptionRev::None"); + }; + + assert_eq!(*value, jit_struct!()); } } diff --git a/src/libfuncs/box.rs b/src/libfuncs/box.rs index 96a50ef52..1769c241d 100644 --- a/src/libfuncs/box.rs +++ b/src/libfuncs/box.rs @@ -152,41 +152,58 @@ pub fn build_unbox<'ctx, 'this>( #[cfg(test)] mod test { + use cairo_lang_sierra::{ + extensions::{ + boxing::{IntoBoxLibfunc, UnboxLibfunc}, + int::unsigned::Uint32Type, + }, + program::GenericArg, + }; + use crate::{ - utils::test::{load_cairo, run_program_assert_output}, + utils::{ + sierra_gen::SierraGenerator, + test::{load_cairo, run_program_assert_output, run_sierra_program}, + }, values::Value, }; #[test] fn run_box_unbox() { - let program = load_cairo! { - use box::BoxTrait; - use box::BoxImpl; + let program_box = { + let mut generator = SierraGenerator::::default(); - fn run_test() -> u32 { - let x: u32 = 2_u32; - let box_x: Box = BoxTrait::new(x); - box_x.unbox() - } + let u32_ty = generator.push_type_declaration::(&[]).clone(); + + generator.build(&[GenericArg::Type(u32_ty)]) }; + let program_unbox = { + let mut generator = SierraGenerator::::default(); + + let u32_ty = generator.push_type_declaration::(&[]).clone(); - run_program_assert_output(&program, "run_test", &[], Value::Uint32(2)); + generator.build(&[GenericArg::Type(u32_ty)]) + }; + + let result = run_sierra_program(&program_box, &[Value::Uint32(2)]).return_value; + let result = run_sierra_program(&program_unbox, &[result]).return_value; + + assert_eq!(result, Value::Uint32(2)); } #[test] fn run_box() { - let program = load_cairo! { - use box::BoxTrait; - use box::BoxImpl; + let program_box = { + let mut generator = SierraGenerator::::default(); - fn run_test() -> Box { - let x: u32 = 2_u32; - let box_x: Box = BoxTrait::new(x); - box_x - } + let u32_ty = generator.push_type_declaration::(&[]).clone(); + + generator.build(&[GenericArg::Type(u32_ty)]) }; - run_program_assert_output(&program, "run_test", &[], Value::Uint32(2)); + let result = run_sierra_program(&program_box, &[Value::Uint32(2)]).return_value; + + assert_eq!(result, Value::Uint32(2)); } #[test] diff --git a/src/libfuncs/bytes31.rs b/src/libfuncs/bytes31.rs index 66006c87a..2a7c65456 100644 --- a/src/libfuncs/bytes31.rs +++ b/src/libfuncs/bytes31.rs @@ -162,39 +162,53 @@ pub fn build_from_felt252<'ctx, 'this>( #[cfg(test)] mod test { - use crate::utils::test::{ - jit_enum, jit_panic, jit_struct, load_cairo, run_program_assert_output, + use crate::{ + utils::{ + sierra_gen::SierraGenerator, + test::{jit_enum, jit_struct, run_sierra_program}, + }, + Value, + }; + use cairo_lang_sierra::{ + extensions::{ + bytes31::{Bytes31FromFelt252Trait, Bytes31ToFelt252Libfunc}, + try_from_felt252::TryFromFelt252Libfunc, + }, + program::Program, }; - use cairo_lang_sierra::program::Program; use lazy_static::lazy_static; use starknet_types_core::felt::Felt; lazy_static! { // TODO: Test `bytes31_const` once the compiler supports it. - static ref BYTES31_ROUNDTRIP: (String, Program) = load_cairo! { - use core::bytes_31::{bytes31_try_from_felt252, bytes31_to_felt252}; + static ref BYTES31_TRY_FROM_FELT: Program = { + let generator = SierraGenerator::>::default(); + + generator.build(&[]) + }; + static ref BYTES31_TO_FELT: Program = { + let generator = SierraGenerator::::default(); - fn run_test(value: felt252) -> felt252 { - let a: bytes31 = bytes31_try_from_felt252(value).unwrap(); - bytes31_to_felt252(a) - } + generator.build(&[]) }; } #[test] fn bytes31_roundtrip() { - run_program_assert_output( - &BYTES31_ROUNDTRIP, - "run_test", - &[Felt::from(2).into()], - jit_enum!(0, jit_struct!(Felt::from(2).into())), - ); - - run_program_assert_output( - &BYTES31_ROUNDTRIP, - "run_test", - &[Felt::MAX.into()], - jit_panic!(Felt::from_bytes_be_slice(b"Option::unwrap failed.")), - ); + let Value::Enum { + tag: _, + value, + debug_name: _, + } = run_sierra_program(&BYTES31_TRY_FROM_FELT, &[Felt::from(2).into()]).return_value + else { + panic!("Invalid result type"); + }; + let result = run_sierra_program(&BYTES31_TO_FELT, &[*value]).return_value; + + assert_eq!(Value::Felt252(2.into()), result); + + let result = run_sierra_program(&BYTES31_TRY_FROM_FELT, &[Felt::MAX.into()]).return_value; + + assert_eq!(jit_enum!(1, jit_struct!()), result); } } diff --git a/src/libfuncs/cast.rs b/src/libfuncs/cast.rs index 8657ac08c..132e61838 100644 --- a/src/libfuncs/cast.rs +++ b/src/libfuncs/cast.rs @@ -391,299 +391,341 @@ pub fn build_upcast<'ctx, 'this>( #[cfg(test)] mod test { use crate::{ - utils::test::{jit_enum, jit_struct, load_cairo, run_program_assert_output}, + utils::{ + sierra_gen::SierraGenerator, + test::{jit_enum, jit_struct, run_sierra_program}, + }, values::Value, }; - use cairo_lang_sierra::program::Program; - use lazy_static::lazy_static; - - lazy_static! { - static ref DOWNCAST: (String, Program) = load_cairo! { - use core::integer::downcast; - - fn run_test( - v8: u8, v16: u16, v32: u32, v64: u64, v128: u128 - ) -> ( - (Option, Option, Option, Option, Option), - (Option, Option, Option, Option), - (Option, Option, Option), - (Option, Option), - (Option,), - ) { - ( - (downcast(v128), downcast(v64), downcast(v32), downcast(v16), downcast(v8)), - (downcast(v128), downcast(v64), downcast(v32), downcast(v16)), - (downcast(v128), downcast(v64), downcast(v32)), - (downcast(v128), downcast(v64)), - (downcast(v128),), - ) - } - }; - static ref UPCAST: (String, Program) = load_cairo! { - use core::integer::upcast; - - fn run_test( - v8: u8, v16: u16, v32: u32, v64: u64, v128: u128, v248: bytes31 - ) -> ( - (u8,), - (u16, u16), - (u32, u32, u32), - (u64, u64, u64, u64), - (u128, u128, u128, u128, u128), - (bytes31, bytes31, bytes31, bytes31, bytes31, bytes31) - ) { - ( - (upcast(v8),), - (upcast(v8), upcast(v16)), - (upcast(v8), upcast(v16), upcast(v32)), - (upcast(v8), upcast(v16), upcast(v32), upcast(v64)), - (upcast(v8), upcast(v16), upcast(v32), upcast(v64), upcast(v128)), - (upcast(v8), upcast(v16), upcast(v32), upcast(v64), upcast(v128), upcast(v248)), - ) + use cairo_lang_sierra::{ + extensions::{ + bytes31::Bytes31Type, + casts::{DowncastLibfunc, UpcastLibfunc}, + int::{ + unsigned::{Uint16Type, Uint32Type, Uint64Type, Uint8Type}, + unsigned128::Uint128Type, + }, + }, + program::GenericArg, + }; + + macro_rules! cast { + ($from:ty, $to:ty, $is_up_cast:expr) => { + if $is_up_cast { + let mut generator = SierraGenerator::::default(); + + let from_ty = generator.push_type_declaration::<$from>(&[]).clone(); + let to_ty = generator.push_type_declaration::<$to>(&[]).clone(); + + generator.build(&[GenericArg::Type(from_ty), GenericArg::Type(to_ty)]) + } else { + let mut generator = SierraGenerator::::default(); + + let from_ty = generator.push_type_declaration::<$from>(&[]).clone(); + let to_ty = generator.push_type_declaration::<$to>(&[]).clone(); + + generator.build(&[GenericArg::Type(from_ty), GenericArg::Type(to_ty)]) } }; } #[test] fn downcast() { - run_program_assert_output( - &DOWNCAST, - "run_test", - &[ - u8::MAX.into(), - u16::MAX.into(), - u32::MAX.into(), - u64::MAX.into(), - u128::MAX.into(), - ], - jit_struct!( - jit_struct!( - jit_enum!(1, jit_struct!()), - jit_enum!(1, jit_struct!()), - jit_enum!(1, jit_struct!()), - jit_enum!(1, jit_struct!()), - jit_enum!(1, jit_struct!()), - ), - jit_struct!( - jit_enum!(1, jit_struct!()), - jit_enum!(1, jit_struct!()), - jit_enum!(1, jit_struct!()), - jit_enum!(1, jit_struct!()), - ), - jit_struct!( - jit_enum!(1, jit_struct!()), - jit_enum!(1, jit_struct!()), - jit_enum!(1, jit_struct!()), - ), - jit_struct!(jit_enum!(1, jit_struct!()), jit_enum!(1, jit_struct!())), - jit_struct!(jit_enum!(1, jit_struct!())), - ), - ); + let result = run_sierra_program(&cast!(Uint128Type, Uint8Type, false), &[u128::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = + run_sierra_program(&cast!(Uint128Type, Uint16Type, false), &[u128::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = + run_sierra_program(&cast!(Uint128Type, Uint32Type, false), &[u128::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = + run_sierra_program(&cast!(Uint128Type, Uint64Type, false), &[u128::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = + run_sierra_program(&cast!(Uint128Type, Uint128Type, false), &[u128::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = run_sierra_program(&cast!(Uint64Type, Uint8Type, false), &[u64::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = run_sierra_program(&cast!(Uint64Type, Uint16Type, false), &[u64::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = run_sierra_program(&cast!(Uint64Type, Uint32Type, false), &[u64::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = run_sierra_program(&cast!(Uint64Type, Uint64Type, false), &[u64::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = run_sierra_program(&cast!(Uint32Type, Uint8Type, false), &[u32::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = run_sierra_program(&cast!(Uint32Type, Uint16Type, false), &[u32::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = run_sierra_program(&cast!(Uint32Type, Uint32Type, false), &[u32::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = run_sierra_program(&cast!(Uint16Type, Uint8Type, false), &[u16::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = run_sierra_program(&cast!(Uint16Type, Uint16Type, false), &[u16::MAX.into()]) + .return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); + let result = + run_sierra_program(&cast!(Uint8Type, Uint8Type, false), &[u8::MAX.into()]).return_value; + assert_eq!(result, jit_enum!(1, jit_struct!())); } #[test] fn upcast() { - run_program_assert_output( - &UPCAST, - "run_test", - &[ - u8::MAX.into(), - u16::MAX.into(), - u32::MAX.into(), - u64::MAX.into(), - u128::MAX.into(), - Value::Bytes31([0xFF; 31]), - ], - jit_struct!( - jit_struct!(u8::MAX.into()), - jit_struct!((u8::MAX as u16).into(), u16::MAX.into()), - jit_struct!( - (u8::MAX as u32).into(), - (u16::MAX as u32).into(), - u32::MAX.into() - ), - jit_struct!( - (u8::MAX as u64).into(), - (u16::MAX as u64).into(), - (u32::MAX as u64).into(), - u64::MAX.into() - ), - jit_struct!( - (u8::MAX as u128).into(), - (u16::MAX as u128).into(), - (u32::MAX as u128).into(), - (u64::MAX as u128).into(), - u128::MAX.into() - ), - jit_struct!( - Value::Bytes31([ - u8::MAX, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]), - Value::Bytes31([ - u8::MAX, - u8::MAX, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]), - Value::Bytes31([ - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]), - Value::Bytes31([ - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]), - Value::Bytes31([ - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]), - Value::Bytes31([u8::MAX; 31]), - ), - ), + let result = + run_sierra_program(&cast!(Uint128Type, Uint128Type, true), &[u128::MAX.into()]) + .return_value; + assert_eq!(result, u128::MAX.into()); + let result = run_sierra_program(&cast!(Uint64Type, Uint128Type, true), &[u64::MAX.into()]) + .return_value; + assert_eq!(result, (u64::MAX as u128).into()); + let result = run_sierra_program(&cast!(Uint64Type, Uint64Type, true), &[u64::MAX.into()]) + .return_value; + assert_eq!(result, u64::MAX.into()); + let result = run_sierra_program(&cast!(Uint32Type, Uint128Type, true), &[u32::MAX.into()]) + .return_value; + assert_eq!(result, (u32::MAX as u128).into()); + let result = run_sierra_program(&cast!(Uint32Type, Uint64Type, true), &[u32::MAX.into()]) + .return_value; + assert_eq!(result, (u32::MAX as u64).into()); + let result = run_sierra_program(&cast!(Uint32Type, Uint32Type, true), &[u32::MAX.into()]) + .return_value; + assert_eq!(result, u32::MAX.into()); + let result = run_sierra_program(&cast!(Uint16Type, Uint128Type, true), &[u16::MAX.into()]) + .return_value; + assert_eq!(result, (u16::MAX as u128).into()); + let result = run_sierra_program(&cast!(Uint16Type, Uint64Type, true), &[u16::MAX.into()]) + .return_value; + assert_eq!(result, (u16::MAX as u64).into()); + let result = run_sierra_program(&cast!(Uint16Type, Uint32Type, true), &[u16::MAX.into()]) + .return_value; + assert_eq!(result, (u16::MAX as u32).into()); + let result = run_sierra_program(&cast!(Uint16Type, Uint16Type, true), &[u16::MAX.into()]) + .return_value; + assert_eq!(result, u16::MAX.into()); + let result = run_sierra_program(&cast!(Uint8Type, Uint128Type, true), &[u8::MAX.into()]) + .return_value; + assert_eq!(result, (u8::MAX as u128).into()); + let result = + run_sierra_program(&cast!(Uint8Type, Uint64Type, true), &[u8::MAX.into()]).return_value; + assert_eq!(result, (u8::MAX as u64).into()); + let result = + run_sierra_program(&cast!(Uint8Type, Uint32Type, true), &[u8::MAX.into()]).return_value; + assert_eq!(result, (u8::MAX as u32).into()); + let result = + run_sierra_program(&cast!(Uint8Type, Uint16Type, true), &[u8::MAX.into()]).return_value; + assert_eq!(result, (u8::MAX as u16).into()); + let result = + run_sierra_program(&cast!(Uint8Type, Uint8Type, true), &[u8::MAX.into()]).return_value; + assert_eq!(result, u8::MAX.into()); + let result = run_sierra_program( + &cast!(Bytes31Type, Bytes31Type, true), + &[Value::Bytes31([0xFF; 31])], + ) + .return_value; + assert_eq!(result, Value::Bytes31([0xFF; 31])); + let result = + run_sierra_program(&cast!(Uint128Type, Bytes31Type, true), &[u128::MAX.into()]) + .return_value; + assert_eq!( + result, + Value::Bytes31([ + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ]) + ); + let result = run_sierra_program(&cast!(Uint64Type, Bytes31Type, true), &[u64::MAX.into()]) + .return_value; + assert_eq!( + result, + Value::Bytes31([ + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ]) + ); + let result = run_sierra_program(&cast!(Uint32Type, Bytes31Type, true), &[u32::MAX.into()]) + .return_value; + assert_eq!( + result, + Value::Bytes31([ + u8::MAX, + u8::MAX, + u8::MAX, + u8::MAX, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ]) + ); + let result = run_sierra_program(&cast!(Uint16Type, Bytes31Type, true), &[u16::MAX.into()]) + .return_value; + assert_eq!( + result, + Value::Bytes31([ + u8::MAX, + u8::MAX, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ]) + ); + let result = run_sierra_program(&cast!(Uint8Type, Bytes31Type, true), &[u8::MAX.into()]) + .return_value; + assert_eq!( + result, + Value::Bytes31([ + u8::MAX, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ]) ); } } diff --git a/src/libfuncs/const.rs b/src/libfuncs/const.rs index a13622833..5bf9540f4 100644 --- a/src/libfuncs/const.rs +++ b/src/libfuncs/const.rs @@ -307,29 +307,78 @@ pub fn build_const_type_value<'ctx, 'this>( #[cfg(test)] pub mod test { + use cairo_lang_sierra::{ + extensions::{ + boxing::UnboxLibfunc, + const_type::{ConstAsBoxLibfunc, ConstType}, + int::signed::Sint32Type, + structure::StructType, + }, + ids::UserTypeId, + program::GenericArg, + }; + use crate::{ - utils::test::{jit_struct, load_cairo, run_program}, + utils::{ + sierra_gen::SierraGenerator, + test::{jit_struct, run_sierra_program}, + }, values::Value, }; #[test] fn run_const_as_box() { - let program = load_cairo!( - use core::box::BoxTrait; + let program_as_const = { + let mut generator = SierraGenerator::::default(); - struct Hello { - x: i32, - } + let i32_ty = generator.push_type_declaration::(&[]).clone(); - fn run_test() -> Hello { - let x = BoxTrait::new(Hello { - x: -2 - }); - x.unbox() - } - ); + let const_i32_ty = generator + .push_type_declaration::(&[ + GenericArg::Type(i32_ty.clone()), + GenericArg::Value((-2).into()), + ]) + .clone(); + + let struct_ty = generator + .push_type_declaration::(&[ + GenericArg::UserType(UserTypeId::from_string("Hello")), + GenericArg::Type(i32_ty), + ]) + .clone(); + + let const_struct_ty = generator + .push_type_declaration::(&[ + GenericArg::Type(struct_ty), + GenericArg::Type(const_i32_ty.clone()), + ]) + .clone(); + + generator.build(&[ + GenericArg::Type(const_struct_ty), + GenericArg::Value(0.into()), + ]) + }; + + let program_unbox = { + let mut generator = SierraGenerator::::default(); + + let i32_type = generator.push_type_declaration::(&[]).clone(); + + let struct_type = generator + .push_type_declaration::(&[ + GenericArg::UserType(UserTypeId::from_string("Hello")), + GenericArg::Type(i32_type), + ]) + .clone(); + + generator.build(&[GenericArg::Type(struct_type)]) + }; + + let result = run_sierra_program(&program_as_const, &[]).return_value; + + let result = run_sierra_program(&program_unbox, &[result]).return_value; - let result = run_program(&program, "run_test", &[]).return_value; assert_eq!(result, jit_struct!(Value::Sint32(-2))); } } diff --git a/src/utils.rs b/src/utils.rs index 86565162a..dc576a746 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -608,6 +608,34 @@ pub mod test { .unwrap() } + // This function receives a sierra program and runs its first entrypoint + // It is used primarely along with the sierra generator + // The difference between this function and run_program is that the latter + // also receives the name of the entrypoint to run + pub fn run_sierra_program(program: &Program, args: &[Value]) -> ExecutionResult { + let entry_point_id = &program + .funcs + .first() + .expect("program entry point not found.") + .id; + + let context = NativeContext::new(); + + let module = context + .compile(program, false, Some(Default::default())) + .expect("Could not compile test program to MLIR."); + + let executor = JitNativeExecutor::from_native_module(module, OptLevel::Less).unwrap(); + executor + .invoke_dynamic_with_syscall_handler( + entry_point_id, + args, + Some(u64::MAX), + &mut StubSyscallHandler::default(), + ) + .unwrap() + } + #[track_caller] pub fn run_program_assert_output( program: &(String, Program), From f066443ed9408cc6074b1438f906db3107bd13da Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Fri, 28 Feb 2025 09:44:32 -0300 Subject: [PATCH 2/7] fix test --- src/values.rs | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/src/values.rs b/src/values.rs index 985535c3b..788e406b0 100644 --- a/src/values.rs +++ b/src/values.rs @@ -175,6 +175,16 @@ impl Value { ) -> Result, Error> { let ty = registry.get_type(type_id)?; + match ty { + CoreTypeConcrete::Box(info) + | CoreTypeConcrete::NonZero(info) + | CoreTypeConcrete::Nullable(info) + | CoreTypeConcrete::Snapshot(info) => { + return self.to_ptr(arena, registry, &info.ty, find_dict_overrides); + } + _ => {} + } + Ok(unsafe { match self { Self::Felt252(value) => { @@ -749,9 +759,7 @@ impl Value { CoreTypeConcrete::Uint32(_) => Self::Uint32(*ptr.cast::().as_ref()), CoreTypeConcrete::Uint64(_) => Self::Uint64(*ptr.cast::().as_ref()), CoreTypeConcrete::Uint128(_) => Self::Uint128(*ptr.cast::().as_ref()), - CoreTypeConcrete::Uint128MulGuarantee(_) => { - native_panic!("todo: implement uint128mulguarantee from_ptr") - } + CoreTypeConcrete::Uint128MulGuarantee(_) => Self::Null, CoreTypeConcrete::Sint8(_) => Self::Sint8(*ptr.cast::().as_ref()), CoreTypeConcrete::Sint16(_) => Self::Sint16(*ptr.cast::().as_ref()), CoreTypeConcrete::Sint32(_) => Self::Sint32(*ptr.cast::().as_ref()), From a3502c9e32ad205e22c94069d1554c6b69c7c9f8 Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Fri, 28 Feb 2025 11:11:50 -0300 Subject: [PATCH 3/7] clean cast.rs --- src/libfuncs/cast.rs | 195 ++++--------------------------------------- 1 file changed, 15 insertions(+), 180 deletions(-) diff --git a/src/libfuncs/cast.rs b/src/libfuncs/cast.rs index 132e61838..db39a70dd 100644 --- a/src/libfuncs/cast.rs +++ b/src/libfuncs/cast.rs @@ -429,6 +429,16 @@ mod test { }; } + fn bytes21_with_filled_u8_max(times: u8) -> Value { + let mut vec = [0; 31]; + + for i in 0..times { + vec[i as usize] = u8::MAX + } + + Value::Bytes31(vec) + } + #[test] fn downcast() { let result = run_sierra_program(&cast!(Uint128Type, Uint8Type, false), &[u128::MAX.into()]) @@ -539,193 +549,18 @@ mod test { let result = run_sierra_program(&cast!(Uint128Type, Bytes31Type, true), &[u128::MAX.into()]) .return_value; - assert_eq!( - result, - Value::Bytes31([ - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]) - ); + assert_eq!(result, bytes21_with_filled_u8_max(16)); let result = run_sierra_program(&cast!(Uint64Type, Bytes31Type, true), &[u64::MAX.into()]) .return_value; - assert_eq!( - result, - Value::Bytes31([ - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]) - ); + assert_eq!(result, bytes21_with_filled_u8_max(8)); let result = run_sierra_program(&cast!(Uint32Type, Bytes31Type, true), &[u32::MAX.into()]) .return_value; - assert_eq!( - result, - Value::Bytes31([ - u8::MAX, - u8::MAX, - u8::MAX, - u8::MAX, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]) - ); + assert_eq!(result, bytes21_with_filled_u8_max(4)); let result = run_sierra_program(&cast!(Uint16Type, Bytes31Type, true), &[u16::MAX.into()]) .return_value; - assert_eq!( - result, - Value::Bytes31([ - u8::MAX, - u8::MAX, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]) - ); + assert_eq!(result, bytes21_with_filled_u8_max(2)); let result = run_sierra_program(&cast!(Uint8Type, Bytes31Type, true), &[u8::MAX.into()]) .return_value; - assert_eq!( - result, - Value::Bytes31([ - u8::MAX, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]) - ); + assert_eq!(result, bytes21_with_filled_u8_max(1)); } } From bc11b41f08ef73c8c3a2d1e31911d68ca1294117 Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Fri, 7 Mar 2025 11:10:20 -0300 Subject: [PATCH 4/7] fix clippy --- src/values.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/values.rs b/src/values.rs index a84875347..8c3b1a7ec 100644 --- a/src/values.rs +++ b/src/values.rs @@ -174,7 +174,7 @@ impl Value { | CoreTypeConcrete::NonZero(info) | CoreTypeConcrete::Nullable(info) | CoreTypeConcrete::Snapshot(info) => { - return self.to_ptr(arena, registry, &info.ty, find_dict_overrides); + return self.to_ptr(arena, registry, &info.ty, find_dict_drop_override); } _ => {} } From 1243c32548cd92b103996d052ae7458d279db044 Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Mon, 10 Mar 2025 16:07:24 -0300 Subject: [PATCH 5/7] reviews --- Cargo.lock | 111 ++++++++++++++++++------------------ program.cairo | 5 ++ src/libfuncs/bounded_int.rs | 47 ++++++++++----- src/libfuncs/bytes31.rs | 7 +-- 4 files changed, 94 insertions(+), 76 deletions(-) create mode 100644 program.cairo diff --git a/Cargo.lock b/Cargo.lock index b506f2458..5c9023550 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -119,7 +119,7 @@ dependencies = [ "proc-macro-error2", "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -217,7 +217,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "62945a2f7e6de02a31fe400aa489f0e0f5b2502e69f95f853adb82a96c7a6b60" dependencies = [ "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -243,7 +243,7 @@ dependencies = [ "num-traits", "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -362,7 +362,7 @@ checksum = "213888f660fddcca0d257e88e54ac05bca01885f258ccdf695bafd77031bb69d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -420,9 +420,9 @@ checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b" [[package]] name = "bincode" -version = "2.0.0" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ad1fa75f77bbd06f187540aa1d70ca50b80b27ce85e7f41c0ce7ff42b34ed3b" +checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740" dependencies = [ "serde", "unty", @@ -445,7 +445,7 @@ dependencies = [ "regex", "rustc-hash 2.1.1", "shlex", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -755,7 +755,7 @@ checksum = "3a98a058656493f4ef4b7fc51ed4fa46cc9b2834262815959746bf1696f1c50f" dependencies = [ "cairo-lang-debug", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -1356,7 +1356,7 @@ dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -1664,7 +1664,7 @@ dependencies = [ "enum-ordinalize", "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -1676,7 +1676,7 @@ dependencies = [ "enum-ordinalize", "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -1723,7 +1723,7 @@ checksum = "0d28318a75d4aead5c4db25382e8ef717932d0346600cacae6357eb5941bc5ff" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -1796,7 +1796,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -1844,7 +1844,7 @@ checksum = "43eaff6bbc0b3a878361aced5ec6a2818ee7c541c5b33b5880dfa9a86c23e9e7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -1973,9 +1973,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" [[package]] name = "hermit-abi" -version = "0.4.0" +version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc" +checksum = "fbd780fe5cc30f81464441920d82ac8740e2e46b29a6fad543ddd075229ce37e" [[package]] name = "hex" @@ -2031,7 +2031,7 @@ checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -2111,9 +2111,9 @@ dependencies = [ [[package]] name = "is-terminal" -version = "0.4.15" +version = "0.4.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e19b23d53f35ce9f56aebc7d1bb4e6ac1e9c0db7ac85c8d1760c04379edced37" +checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9" dependencies = [ "hermit-abi", "libc", @@ -2388,7 +2388,7 @@ dependencies = [ "proc-macro2", "quote", "regex", - "syn 2.0.99", + "syn 2.0.100", "tblgen", "unindent", ] @@ -2554,15 +2554,15 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3" [[package]] name = "once_cell" -version = "1.20.3" +version = "1.21.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "945462a4b81e43c4e3ba96bd7b49d834c6f61198356aa858733bc4acf3cbe62e" +checksum = "cde51589ab56b20a6f686b2c68f7a0bd6add753d697abf720d63f8db3ab7b1ad" [[package]] name = "oorandom" -version = "11.1.4" +version = "11.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b410bbe7e14ab526a0e86877eb47c6996a2bd7746f027ba551028c925390e4e9" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" [[package]] name = "ordered-float" @@ -2604,7 +2604,7 @@ dependencies = [ "proc-macro-crate", "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -2759,11 +2759,11 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" [[package]] name = "ppv-lite86" -version = "0.2.20" +version = "0.2.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" dependencies = [ - "zerocopy 0.7.35", + "zerocopy 0.8.23", ] [[package]] @@ -2799,7 +2799,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f1ccf34da56fc294e7d4ccf69a85992b7dfb826b7cf57bac6a70bba3494cc08a" dependencies = [ "proc-macro2", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -3089,7 +3089,7 @@ dependencies = [ "regex", "relative-path", "rustc_version", - "syn 2.0.99", + "syn 2.0.100", "unicode-ident", ] @@ -3119,7 +3119,7 @@ dependencies = [ "heck 0.4.1", "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -3155,9 +3155,9 @@ dependencies = [ [[package]] name = "rustix" -version = "1.0.0" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "17f8dcd64f141950290e45c99f7710ede1b600297c91818bb30b3667c0f45dc0" +checksum = "f7178faa4b75a30e269c71e61c353ce2748cf3d76f0c44c393f4e60abf49b825" dependencies = [ "bitflags", "errno", @@ -3251,7 +3251,7 @@ dependencies = [ "proc-macro2", "quote", "serde_derive_internals", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -3271,22 +3271,22 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.218" +version = "1.0.219" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8dfc9d19bdbf6d17e22319da49161d5d0108e4188e8b680aef6299eed22df60" +checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.218" +version = "1.0.219" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f09503e191f4e797cb8aac08e9a4a4695c5edf6a2e70e376d961ddd5c969f82b" +checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -3297,7 +3297,7 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -3479,7 +3479,7 @@ checksum = "bbc159a1934c7be9761c237333a57febe060ace2bc9e3b337a59a37af206d19f" dependencies = [ "starknet-curve 0.4.2", "starknet-ff", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -3570,9 +3570,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.99" +version = "2.0.100" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e02e925281e18ffd9d640e234264753c43edc62d64b2d4cf898f1bc5e75f3fc2" +checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0" dependencies = [ "proc-macro2", "quote", @@ -3640,7 +3640,7 @@ dependencies = [ "cfg-if", "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -3651,7 +3651,7 @@ checksum = "5c89e72a01ed4c579669add59014b9a524d609c0c88c6a585ce37485879f6ffb" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", "test-case-core", ] @@ -3681,7 +3681,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -3692,7 +3692,7 @@ checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -3831,7 +3831,7 @@ checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -3970,9 +3970,9 @@ checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3" [[package]] name = "unty" -version = "0.0.3" +version = "0.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1a88342087869553c259588a3ec9ca73ce9b2d538b7051ba5789ff236b6c129" +checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae" [[package]] name = "utf8-width" @@ -4059,7 +4059,7 @@ dependencies = [ "once_cell", "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", "wasm-bindgen-shared", ] @@ -4081,7 +4081,7 @@ checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -4270,7 +4270,6 @@ version = "0.7.35" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0" dependencies = [ - "byteorder", "zerocopy-derive 0.7.35", ] @@ -4291,7 +4290,7 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -4302,7 +4301,7 @@ checksum = "6352c01d0edd5db859a63e2605f4ea3183ddbd15e2c4a9e7d32184df75e4f154" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] @@ -4322,7 +4321,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ "proc-macro2", "quote", - "syn 2.0.99", + "syn 2.0.100", ] [[package]] diff --git a/program.cairo b/program.cairo new file mode 100644 index 000000000..1899932f7 --- /dev/null +++ b/program.cairo @@ -0,0 +1,5 @@ +use starknet::class_hash::ClassHash; + +fn run_program() -> ClassHash { + 0.try_into().unwrap() +} diff --git a/src/libfuncs/bounded_int.rs b/src/libfuncs/bounded_int.rs index c1392785f..95130a2b7 100644 --- a/src/libfuncs/bounded_int.rs +++ b/src/libfuncs/bounded_int.rs @@ -824,10 +824,12 @@ mod test { signed::{Sint16Type, Sint8Type}, unsigned::Uint32Type, }, + utils::Range, }, program::GenericArg, }; use cairo_vm::Felt252; + use num_bigint::BigInt; use crate::{ utils::{ @@ -854,11 +856,16 @@ mod test { panic!("should be OptionRev::Some"); }; - let Value::BoundedInt { value, range: _ } = *value else { - panic!(); - }; - - assert_eq!(value, Felt252::from(1_u8)); + assert_eq!( + *value, + Value::BoundedInt { + value: 1_u8.into(), + range: Range { + lower: BigInt::from(i8::MIN), + upper: BigInt::from(i8::MAX) + } + } + ); } #[test] @@ -878,11 +885,16 @@ mod test { panic!("should be OptionRev::Some"); }; - let Value::BoundedInt { value, range: _ } = *value else { - panic!(); - }; - - assert_eq!(value, Felt252::from(-1_i8)); + assert_eq!( + *value, + Value::BoundedInt { + value: (-1_i8).into(), + range: Range { + lower: BigInt::from(i8::MIN), + upper: BigInt::from(i8::MAX) + } + } + ); } #[test] @@ -903,11 +915,16 @@ mod test { panic!("should be OptionRev::Some"); }; - let Value::BoundedInt { value, range: _ } = *value else { - panic!(); - }; - - assert_eq!(value, Felt252::from(0xfffffffe_u32)); + assert_eq!( + *value, + Value::BoundedInt { + value: 0xfffffffeu32.into(), + range: Range { + lower: 0.into(), + upper: u32::MAX.into() + } + } + ); } #[test] diff --git a/src/libfuncs/bytes31.rs b/src/libfuncs/bytes31.rs index 2a7c65456..aee06a94e 100644 --- a/src/libfuncs/bytes31.rs +++ b/src/libfuncs/bytes31.rs @@ -195,11 +195,8 @@ mod test { #[test] fn bytes31_roundtrip() { - let Value::Enum { - tag: _, - value, - debug_name: _, - } = run_sierra_program(&BYTES31_TRY_FROM_FELT, &[Felt::from(2).into()]).return_value + let Value::Enum { value, .. } = + run_sierra_program(&BYTES31_TRY_FROM_FELT, &[Felt::from(2).into()]).return_value else { panic!("Invalid result type"); }; From b2abe2cbac9aab358cd0388e83599a3575083fe2 Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Mon, 10 Mar 2025 16:07:49 -0300 Subject: [PATCH 6/7] remove cairo program --- program.cairo | 5 ----- 1 file changed, 5 deletions(-) delete mode 100644 program.cairo diff --git a/program.cairo b/program.cairo deleted file mode 100644 index 1899932f7..000000000 --- a/program.cairo +++ /dev/null @@ -1,5 +0,0 @@ -use starknet::class_hash::ClassHash; - -fn run_program() -> ClassHash { - 0.try_into().unwrap() -} From 377cf017b8c62fe54f8fedf818d4d95e1784a175 Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Tue, 11 Mar 2025 09:26:06 -0300 Subject: [PATCH 7/7] fix casts tests and clippy --- src/libfuncs/bounded_int.rs | 1 - src/libfuncs/cast.rs | 277 ++++++++++++++++++++++++------------ 2 files changed, 183 insertions(+), 95 deletions(-) diff --git a/src/libfuncs/bounded_int.rs b/src/libfuncs/bounded_int.rs index 95130a2b7..ba8366027 100644 --- a/src/libfuncs/bounded_int.rs +++ b/src/libfuncs/bounded_int.rs @@ -828,7 +828,6 @@ mod test { }, program::GenericArg, }; - use cairo_vm::Felt252; use num_bigint::BigInt; use crate::{ diff --git a/src/libfuncs/cast.rs b/src/libfuncs/cast.rs index db39a70dd..b036af1da 100644 --- a/src/libfuncs/cast.rs +++ b/src/libfuncs/cast.rs @@ -405,28 +405,18 @@ mod test { unsigned::{Uint16Type, Uint32Type, Uint64Type, Uint8Type}, unsigned128::Uint128Type, }, + GenericLibfunc, NamedType, }, - program::GenericArg, + program::{GenericArg, Program}, }; - macro_rules! cast { - ($from:ty, $to:ty, $is_up_cast:expr) => { - if $is_up_cast { - let mut generator = SierraGenerator::::default(); + fn cast() -> Program { + let mut generator = SierraGenerator::::default(); - let from_ty = generator.push_type_declaration::<$from>(&[]).clone(); - let to_ty = generator.push_type_declaration::<$to>(&[]).clone(); + let from_ty = generator.push_type_declaration::(&[]).clone(); + let to_ty = generator.push_type_declaration::(&[]).clone(); - generator.build(&[GenericArg::Type(from_ty), GenericArg::Type(to_ty)]) - } else { - let mut generator = SierraGenerator::::default(); - - let from_ty = generator.push_type_declaration::<$from>(&[]).clone(); - let to_ty = generator.push_type_declaration::<$to>(&[]).clone(); - - generator.build(&[GenericArg::Type(from_ty), GenericArg::Type(to_ty)]) - } - }; + generator.build(&[GenericArg::Type(from_ty), GenericArg::Type(to_ty)]) } fn bytes21_with_filled_u8_max(times: u8) -> Value { @@ -441,126 +431,225 @@ mod test { #[test] fn downcast() { - let result = run_sierra_program(&cast!(Uint128Type, Uint8Type, false), &[u128::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u128::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = - run_sierra_program(&cast!(Uint128Type, Uint16Type, false), &[u128::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u128::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = - run_sierra_program(&cast!(Uint128Type, Uint32Type, false), &[u128::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u128::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = - run_sierra_program(&cast!(Uint128Type, Uint64Type, false), &[u128::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u128::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = - run_sierra_program(&cast!(Uint128Type, Uint128Type, false), &[u128::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u128::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_sierra_program(&cast!(Uint64Type, Uint8Type, false), &[u64::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u64::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_sierra_program(&cast!(Uint64Type, Uint16Type, false), &[u64::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u64::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_sierra_program(&cast!(Uint64Type, Uint32Type, false), &[u64::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u64::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_sierra_program(&cast!(Uint64Type, Uint64Type, false), &[u64::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u64::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_sierra_program(&cast!(Uint32Type, Uint8Type, false), &[u32::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u32::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_sierra_program(&cast!(Uint32Type, Uint16Type, false), &[u32::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u32::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_sierra_program(&cast!(Uint32Type, Uint32Type, false), &[u32::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u32::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_sierra_program(&cast!(Uint16Type, Uint8Type, false), &[u16::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u16::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = run_sierra_program(&cast!(Uint16Type, Uint16Type, false), &[u16::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u16::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); - let result = - run_sierra_program(&cast!(Uint8Type, Uint8Type, false), &[u8::MAX.into()]).return_value; + let result = run_sierra_program( + &cast::(), + &[u8::MAX.into()], + ) + .return_value; assert_eq!(result, jit_enum!(1, jit_struct!())); } #[test] fn upcast() { - let result = - run_sierra_program(&cast!(Uint128Type, Uint128Type, true), &[u128::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u128::MAX.into()], + ) + .return_value; assert_eq!(result, u128::MAX.into()); - let result = run_sierra_program(&cast!(Uint64Type, Uint128Type, true), &[u64::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u64::MAX.into()], + ) + .return_value; assert_eq!(result, (u64::MAX as u128).into()); - let result = run_sierra_program(&cast!(Uint64Type, Uint64Type, true), &[u64::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u64::MAX.into()], + ) + .return_value; assert_eq!(result, u64::MAX.into()); - let result = run_sierra_program(&cast!(Uint32Type, Uint128Type, true), &[u32::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u32::MAX.into()], + ) + .return_value; assert_eq!(result, (u32::MAX as u128).into()); - let result = run_sierra_program(&cast!(Uint32Type, Uint64Type, true), &[u32::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u32::MAX.into()], + ) + .return_value; assert_eq!(result, (u32::MAX as u64).into()); - let result = run_sierra_program(&cast!(Uint32Type, Uint32Type, true), &[u32::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u32::MAX.into()], + ) + .return_value; assert_eq!(result, u32::MAX.into()); - let result = run_sierra_program(&cast!(Uint16Type, Uint128Type, true), &[u16::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u16::MAX.into()], + ) + .return_value; assert_eq!(result, (u16::MAX as u128).into()); - let result = run_sierra_program(&cast!(Uint16Type, Uint64Type, true), &[u16::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u16::MAX.into()], + ) + .return_value; assert_eq!(result, (u16::MAX as u64).into()); - let result = run_sierra_program(&cast!(Uint16Type, Uint32Type, true), &[u16::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u16::MAX.into()], + ) + .return_value; assert_eq!(result, (u16::MAX as u32).into()); - let result = run_sierra_program(&cast!(Uint16Type, Uint16Type, true), &[u16::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u16::MAX.into()], + ) + .return_value; assert_eq!(result, u16::MAX.into()); - let result = run_sierra_program(&cast!(Uint8Type, Uint128Type, true), &[u8::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u8::MAX.into()], + ) + .return_value; assert_eq!(result, (u8::MAX as u128).into()); - let result = - run_sierra_program(&cast!(Uint8Type, Uint64Type, true), &[u8::MAX.into()]).return_value; + let result = run_sierra_program( + &cast::(), + &[u8::MAX.into()], + ) + .return_value; assert_eq!(result, (u8::MAX as u64).into()); - let result = - run_sierra_program(&cast!(Uint8Type, Uint32Type, true), &[u8::MAX.into()]).return_value; + let result = run_sierra_program( + &cast::(), + &[u8::MAX.into()], + ) + .return_value; assert_eq!(result, (u8::MAX as u32).into()); - let result = - run_sierra_program(&cast!(Uint8Type, Uint16Type, true), &[u8::MAX.into()]).return_value; + let result = run_sierra_program( + &cast::(), + &[u8::MAX.into()], + ) + .return_value; assert_eq!(result, (u8::MAX as u16).into()); - let result = - run_sierra_program(&cast!(Uint8Type, Uint8Type, true), &[u8::MAX.into()]).return_value; + let result = run_sierra_program( + &cast::(), + &[u8::MAX.into()], + ) + .return_value; assert_eq!(result, u8::MAX.into()); let result = run_sierra_program( - &cast!(Bytes31Type, Bytes31Type, true), + &cast::(), &[Value::Bytes31([0xFF; 31])], ) .return_value; assert_eq!(result, Value::Bytes31([0xFF; 31])); - let result = - run_sierra_program(&cast!(Uint128Type, Bytes31Type, true), &[u128::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u128::MAX.into()], + ) + .return_value; assert_eq!(result, bytes21_with_filled_u8_max(16)); - let result = run_sierra_program(&cast!(Uint64Type, Bytes31Type, true), &[u64::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u64::MAX.into()], + ) + .return_value; assert_eq!(result, bytes21_with_filled_u8_max(8)); - let result = run_sierra_program(&cast!(Uint32Type, Bytes31Type, true), &[u32::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u32::MAX.into()], + ) + .return_value; assert_eq!(result, bytes21_with_filled_u8_max(4)); - let result = run_sierra_program(&cast!(Uint16Type, Bytes31Type, true), &[u16::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u16::MAX.into()], + ) + .return_value; assert_eq!(result, bytes21_with_filled_u8_max(2)); - let result = run_sierra_program(&cast!(Uint8Type, Bytes31Type, true), &[u8::MAX.into()]) - .return_value; + let result = run_sierra_program( + &cast::(), + &[u8::MAX.into()], + ) + .return_value; assert_eq!(result, bytes21_with_filled_u8_max(1)); } }