def test_type_casts(src: str, dest: str, explicit_cast: bool, unpacking_cast: bool, assign_cast: bool): src_type = parse_type(src) dest_type = parse_type(dest) expr = parse_expr('[ap]') actual_results = [ check_cast(src_type=src_type, dest_type=dest_type, cast_type=cast_type, expr=expr) for cast_type in [CastType.EXPLICIT, CastType.UNPACKING, CastType.ASSIGN] ] expected_results = [explicit_cast, unpacking_cast, assign_cast] assert actual_results == expected_results
def test_typed_references(): scope = TEST_SCOPE program = preprocess_str(code=""" func main(): struct T: member pad0 : felt member pad1 : felt member pad2 : felt member b : T* end struct Struct: member pad0 : felt member pad1 : felt member a : T* end let x : Struct* = cast(ap + 10, Struct*) let y : Struct = [x] [fp] = x.a assert [fp] = cast(x.a.b, felt) assert [fp] = cast(x.a.b.b, felt) [fp] = y.a + 1 ret end """, prime=PRIME, main_scope=scope) def get_reference(name): scoped_name = scope + name assert isinstance(program.identifiers.get_by_full_name(scoped_name), ReferenceDefinition) return program.instructions[-1].flow_tracking_data.resolve_reference( reference_manager=program.reference_manager, name=scoped_name) expected_type_x = mark_type_resolved(parse_type(f'{scope}.main.Struct*')) assert simplify_type_system(get_reference('main.x').value)[1] == expected_type_x expected_type_y = mark_type_resolved(parse_type(f'{scope}.main.Struct')) reference = get_reference('main.y') assert simplify_type_system(reference.value)[1] == expected_type_y assert reference.value.format() == f'cast([ap + 10], {scope}.main.Struct)' assert program.format() == """\
def test_return_value_reference(): program = preprocess_str(code=""" func foo() -> (val, x, y): ret end func main(): let x = call foo [ap] = 0; ap++ x.val = 9 let y : main.Return = call foo let z = call abs 0 ret end """, prime=PRIME) scope = ScopedName.from_string assert isinstance(program.identifiers.get_by_full_name(scope('main.x')), ReferenceDefinition) expected_type = mark_type_resolved( parse_type(f'foo.{CodeElementFunction.RETURN_SCOPE}')) reference = program.instructions[-1].flow_tracking_data.resolve_reference( reference_manager=program.reference_manager, name=scope('main.x')) assert simplify_type_system(reference.value)[1] == expected_type assert isinstance(program.identifiers.get_by_full_name(scope('main.y')), ReferenceDefinition) expected_type = mark_type_resolved( parse_type(f'main.{CodeElementFunction.RETURN_SCOPE}')) reference = program.instructions[-1].flow_tracking_data.resolve_reference( reference_manager=program.reference_manager, name=scope('main.y')) assert simplify_type_system(reference.value)[1] == expected_type assert isinstance(program.identifiers.get_by_full_name(scope('main.z')), ReferenceDefinition) expected_type = parse_type('felt') reference = program.instructions[-1].flow_tracking_data.resolve_reference( reference_manager=program.reference_manager, name=scope('main.z')) assert simplify_type_system(reference.value)[1] == expected_type assert program.format() == """\
def test_typed_references(): program = preprocess_str(code=""" func main(): struct T: member b : T* = 3 end struct Struct: member a : T* = 2 end let x : Struct* = cast(ap + 10, Struct*) let y : Struct = [x] [fp] = x.a assert [fp] = x.a.b assert [fp] = x.a.b.b [fp] = y.a + 1 ret end """, prime=PRIME) scope = ScopedName.from_string assert isinstance(program.identifiers.get_by_full_name(scope('main.x')), ReferenceDefinition) expected_type_x = mark_type_resolved(parse_type('main.Struct*')) reference = program.instructions[-1].flow_tracking_data.resolve_reference( reference_manager=program.reference_manager, name=scope('main.x')) assert simplify_type_system(reference.value)[1] == \ expected_type_x assert isinstance(program.identifiers.get_by_full_name(scope('main.y')), ReferenceDefinition) expected_type_y = mark_type_resolved(parse_type('main.Struct')) reference = program.instructions[-1].flow_tracking_data.resolve_reference( reference_manager=program.reference_manager, name=scope('main.y')) assert simplify_type_system(reference.value)[1] == \ expected_type_y assert reference.value.format() == \ 'cast([ap + 10], main.Struct)' assert program.format() == """\
def test_check_felts_only_type(): program = preprocess_str(""" struct A: member x : felt end struct B: end struct C: member x : felt member y : (felt, A, B) member z : A end struct D: member x : felt* end struct E: member x : D end """) for (typ, expected_res) in [ # Positive cases. ('test_scope.A', True), ('test_scope.B', True), ('test_scope.C', True), ('(felt, felt)', True), ('(felt, (felt, test_scope.C))', True), # Negative cases. ('test_scope.D', False), ('test_scope.E', False), ('(felt, test_scope.D)', False), ]: assert check_felts_only_type( cairo_type=mark_type_resolved(parse_type(typ)), identifier_manager=program.identifiers) == expected_res
def test_types(): assert isinstance(parse_type('felt'), TypeFelt) assert parse_type( 'my_namespace.MyStruct * *').format() == 'my_namespace.MyStruct**'
def test_type_tuple(): typ = parse_type('(felt)') assert typ == TypeTuple(members=[TypeFelt()]) assert typ.format() == '(felt)' assert parse_type('( felt, felt* , (felt, T.S,)* )').format( ) == '(felt, felt*, (felt, T.S)*)'
def _deserialize(self, value, attr, data, **kwargs): return mark_type_resolved(parse_type(value))