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))
