def test_reference_rebinding():
identifier_values = {
scope('ref'):
ReferenceDefinition(
full_name=scope('ref'),
cairo_type=TypeFelt(),
references=[],
)
}
reference_manager = ReferenceManager()
flow_tracking_data = FlowTrackingDataActual(ap_tracking=RegTrackingData())
consts = get_vm_consts(identifier_values, reference_manager,
flow_tracking_data)
with pytest.raises(FlowTrackingError, match='Reference ref revoked'):
consts.ref
flow_tracking_data = flow_tracking_data.add_reference(
reference_manager=reference_manager,
name=scope('ref'),
ref=Reference(
pc=10,
value=parse_expr('10'),
ap_tracking_data=RegTrackingData(group=0, offset=2),
),
)
consts = get_vm_consts(identifier_values, reference_manager,
flow_tracking_data)
assert consts.ref == 10
def test_reference_to_structs():
t = TypeStruct(scope=scope('T'), is_fully_resolved=True)
t_star = TypePointer(pointee=t)
identifier_values = {
scope('ref'): ReferenceDefinition(full_name=scope('ref'),
references=[]),
scope('T.x'): MemberDefinition(offset=3, cairo_type=t_star),
}
reference_manager = ReferenceManager()
flow_tracking_data = FlowTrackingDataActual(ap_tracking=RegTrackingData())
flow_tracking_data = flow_tracking_data.add_reference(
reference_manager=reference_manager,
name=scope('ref'),
ref=Reference(
pc=0,
value=mark_types_in_expr_resolved(parse_expr('cast([100], T)')),
ap_tracking_data=RegTrackingData(group=0, offset=2),
))
consts = get_vm_consts(identifier_values,
reference_manager,
flow_tracking_data,
memory={103: 200})
assert consts.ref.address_ == 100
assert consts.ref.x == 200
def test_revoked_reference():
reference_manager = ReferenceManager()
ref_id = reference_manager.alloc_id(reference=Reference(
pc=0,
value=parse_expr('[ap + 1]'),
ap_tracking_data=RegTrackingData(group=0, offset=2),
))
identifier_values = {
scope('x'):
ReferenceDefinition(full_name=scope('x'),
cairo_type=TypeFelt(),
references=[]),
}
prime = 2**64 + 13
ap = 100
fp = 200
memory = {}
flow_tracking_data = FlowTrackingDataActual(
ap_tracking=RegTrackingData(group=1, offset=4),
reference_ids={scope('x'): ref_id},
)
context = VmConstsContext(
identifiers=IdentifierManager.from_dict(identifier_values),
evaluator=ExpressionEvaluator(prime, ap, fp, memory).eval,
reference_manager=reference_manager,
flow_tracking_data=flow_tracking_data,
memory=memory,
pc=0)
consts = VmConsts(context=context, accessible_scopes=[ScopedName()])
with pytest.raises(FlowTrackingError, match='Failed to deduce ap.'):
assert consts.x
def test_unsupported_attribute():
class UnsupportedIdentifier(IdentifierDefinition):
TYPE: ClassVar[str] = 'tested_t'
identifier_values = {
scope('x'): UnsupportedIdentifier(),
scope('y.z'): UnsupportedIdentifier(),
}
context = VmConstsContext(
identifiers=IdentifierManager.from_dict(identifier_values),
evaluator=dummy_evaluator,
reference_manager=ReferenceManager(),
flow_tracking_data=FlowTrackingDataActual(
ap_tracking=RegTrackingData()),
memory={},
pc=0)
consts = VmConsts(context=context, accessible_scopes=[scope('')])
# Identifier in root namespace.
with pytest.raises(
NotImplementedError,
match="Unsupported identifier type 'tested_t' of identifier 'x'."):
consts.x
# Identifier in sub namespace.
with pytest.raises(
NotImplementedError,
match="Unsupported identifier type 'tested_t' of identifier 'y.z'."
):
consts.y.z
def test_offset_reference_definition_typed_members():
t = TypeStruct(scope=scope('T'), is_fully_resolved=True)
t_star = TypePointer(pointee=t)
reference_manager = ReferenceManager()
main_reference = ReferenceDefinition(full_name=scope('a'),
cairo_type=t_star,
references=[])
references = {
scope('a'):
reference_manager.alloc_id(
Reference(
pc=0,
value=mark_types_in_expr_resolved(parse_expr('cast(ap, T*)')),
ap_tracking_data=RegTrackingData(group=0, offset=0),
)),
}
flow_tracking_data = FlowTrackingDataActual(
ap_tracking=RegTrackingData(group=0, offset=1),
reference_ids=references,
)
# Create OffsetReferenceDefinition instance for an expression of the form "a.<member_path>",
# in this case a.x.y.z, and check the result of evaluation of this expression.
definition = OffsetReferenceDefinition(parent=main_reference,
member_path=scope('x.y.z'))
assert definition.eval(reference_manager=reference_manager,
flow_tracking_data=flow_tracking_data).format(
) == 'cast(ap - 1, T*).x.y.z'
def dummy_instruction_location(filename: str, content: Optional[str]) -> InstructionLocation:
location = Location(
start_line=1, start_col=2, end_line=3, end_col=4,
input_file=InputFile(filename=filename, content=content))
return InstructionLocation(
inst=location, hints=[], accessible_scopes=[],
flow_tracking_data=FlowTrackingDataActual.new(lambda: 0))
def test_missing_attributes():
identifier_values = {
scope('x.y'): ConstDefinition(1),
scope('z'): AliasDefinition(scope('x')),
scope('x.missing'): AliasDefinition(scope('nothing')),
}
context = VmConstsContext(
identifiers=IdentifierManager.from_dict(identifier_values), evaluator=dummy_evaluator,
reference_manager=ReferenceManager(),
flow_tracking_data=FlowTrackingDataActual(ap_tracking=RegTrackingData()), memory={}, pc=0)
consts = VmConsts(context=context, accessible_scopes=[ScopedName()])
# Identifier not exists anywhere.
with pytest.raises(MissingIdentifierError, match="Unknown identifier 'xx'."):
consts.xx
# Identifier not exists in accessible scopes.
with pytest.raises(MissingIdentifierError, match="Unknown identifier 'y'."):
consts.y
# Recursive search.
with pytest.raises(MissingIdentifierError, match="Unknown identifier 'x.z'."):
consts.x.z
# Pass through alias.
with pytest.raises(MissingIdentifierError, match="Unknown identifier 'z.x'."):
consts.z.x
# Pass through bad alias.
with pytest.raises(
IdentifierError,
match="Alias resolution failed: x.missing -> nothing. Unknown identifier 'nothing'."):
consts.x.missing.y
def test_get_dunder_something():
context = VmConstsContext(
identifiers=IdentifierManager(), evaluator=dummy_evaluator,
reference_manager=ReferenceManager(),
flow_tracking_data=FlowTrackingDataActual(ap_tracking=RegTrackingData()), memory={}, pc=0)
consts = VmConsts(context=context, accessible_scopes=[scope('')])
with pytest.raises(
AttributeError,
match=re.escape("'VmConsts' object has no attribute '__something'")):
consts.__something
def test_scope_order():
identifier_values = {
scope('x.y'): ConstDefinition(1),
scope('y'): ConstDefinition(2),
}
context = VmConstsContext(
identifiers=IdentifierManager.from_dict(identifier_values), evaluator=dummy_evaluator,
reference_manager=ReferenceManager(),
flow_tracking_data=FlowTrackingDataActual(ap_tracking=RegTrackingData()), memory={}, pc=0)
consts = VmConsts(context=context, accessible_scopes=[ScopedName(), scope('x')])
assert consts.y == 1
assert consts.x.y == 1
def test_offset_reference_definition_typed_members():
t = TypeStruct(scope=scope('T'), is_fully_resolved=True)
s_star = TypePointer(
pointee=TypeStruct(scope=scope('S'), is_fully_resolved=True))
reference_manager = ReferenceManager()
identifiers = {
scope('T'): ScopeDefinition(),
scope('T.x'): MemberDefinition(offset=3, cairo_type=s_star),
scope('T.flt'): MemberDefinition(offset=4, cairo_type=TypeFelt()),
scope('S'): ScopeDefinition(),
scope('S.x'): MemberDefinition(offset=10, cairo_type=t),
}
main_reference = ReferenceDefinition(full_name=scope('a'), references=[])
references = {
scope('a'):
reference_manager.get_id(
Reference(
pc=0,
value=mark_types_in_expr_resolved(parse_expr('cast(ap, T*)')),
ap_tracking_data=RegTrackingData(group=0, offset=0),
)),
}
flow_tracking_data = FlowTrackingDataActual(
ap_tracking=RegTrackingData(group=0, offset=1),
reference_ids=references,
)
# Create OffsetReferenceDefinition instances for expressions of the form "a.<member_path>",
# such as a.x and a.x.x, and check the result of evaluation those expressions.
for member_path, expected_result in [
('x', 'cast([ap - 1 + 3], S*)'),
('x.x', 'cast([[ap - 1 + 3] + 10], T)'),
('x.x.x', 'cast([&[[ap - 1 + 3] + 10] + 3], S*)'),
('x.x.flt', 'cast([&[[ap - 1 + 3] + 10] + 4], felt)')
]:
definition = OffsetReferenceDefinition(parent=main_reference,
identifier_values=identifiers,
member_path=scope(member_path))
assert definition.eval(
reference_manager=reference_manager,
flow_tracking_data=flow_tracking_data).format() == expected_result
definition = OffsetReferenceDefinition(parent=main_reference,
identifier_values=identifiers,
member_path=scope('x.x.flt.x'))
with pytest.raises(
DefinitionError,
match='Member access requires a type of the form Struct*.'):
assert definition.eval(
reference_manager=reference_manager,
flow_tracking_data=flow_tracking_data).format() == expected_result
def test_unparsed():
identifier_values = {
scope('x'): LabelDefinition(10),
}
context = VmConstsContext(
identifiers=IdentifierManager.from_dict(identifier_values),
evaluator=dummy_evaluator,
reference_manager=ReferenceManager(),
flow_tracking_data=FlowTrackingDataActual(ap_tracking=RegTrackingData()), memory={}, pc=0)
consts = VmConsts(context=context, accessible_scopes=[scope('')])
with pytest.raises(IdentifierError, match="Unexpected '.' after 'x' which is label."):
consts.x.z
def test_reference_to_structs():
t = TypeStruct(scope=scope('T'), is_fully_resolved=True)
t_star = TypePointer(pointee=t)
identifier_values = {
scope('ref'): ReferenceDefinition(
full_name=scope('ref'), cairo_type=t, references=[]
),
scope('T'): StructDefinition(
full_name=scope('T'),
members={
'x': MemberDefinition(offset=3, cairo_type=t_star),
},
size=4,
),
}
reference_manager = ReferenceManager()
flow_tracking_data = FlowTrackingDataActual(ap_tracking=RegTrackingData())
flow_tracking_data = flow_tracking_data.add_reference(
reference_manager=reference_manager,
name=scope('ref'),
ref=Reference(
pc=0,
value=mark_types_in_expr_resolved(parse_expr('[cast(100, T*)]')),
ap_tracking_data=RegTrackingData(group=0, offset=2),
),
)
memory = {103: 200}
consts = get_vm_consts(
identifier_values, reference_manager, flow_tracking_data, memory=memory)
assert consts.ref.address_ == 100
assert consts.ref.x.address_ == 200
# Set the pointer ref.x.x to 300.
consts.ref.x.x = 300
assert memory[203] == 300
assert consts.ref.x.x.address_ == 300
assert consts.ref.type_ == consts.T
def test_references():
reference_manager = ReferenceManager()
references = {
scope('x.ref'):
reference_manager.alloc_id(
Reference(
pc=0,
value=parse_expr('[ap + 1]'),
ap_tracking_data=RegTrackingData(group=0, offset=2),
)),
scope('x.ref2'):
reference_manager.alloc_id(
Reference(
pc=0,
value=parse_expr('[ap + 1] + 0'),
ap_tracking_data=RegTrackingData(group=0, offset=2),
)),
scope('x.ref3'):
reference_manager.alloc_id(
Reference(
pc=0,
value=parse_expr('ap + 1'),
ap_tracking_data=RegTrackingData(group=0, offset=2),
)),
scope('x.typeref'):
reference_manager.alloc_id(
Reference(
pc=0,
value=mark_types_in_expr_resolved(
parse_expr('cast(ap + 1, MyStruct*)')),
ap_tracking_data=RegTrackingData(group=0, offset=3),
)),
scope('x.typeref2'):
reference_manager.alloc_id(
Reference(
pc=0,
value=mark_types_in_expr_resolved(
parse_expr('cast([ap + 1], MyStruct*)')),
ap_tracking_data=RegTrackingData(group=0, offset=3),
)),
}
my_struct_star = TypePointer(
pointee=TypeStruct(scope=scope('MyStruct'), is_fully_resolved=True))
identifier_values = {
scope('x.ref'):
ReferenceDefinition(full_name=scope('x.ref'),
cairo_type=TypeFelt(),
references=[]),
scope('x.ref2'):
ReferenceDefinition(full_name=scope('x.ref2'),
cairo_type=TypeFelt(),
references=[]),
scope('x.ref3'):
ReferenceDefinition(full_name=scope('x.ref3'),
cairo_type=TypeFelt(),
references=[]),
scope('x.typeref'):
ReferenceDefinition(full_name=scope('x.typeref'),
cairo_type=my_struct_star,
references=[]),
scope('x.typeref2'):
ReferenceDefinition(full_name=scope('x.typeref2'),
cairo_type=my_struct_star,
references=[]),
scope('MyStruct'):
StructDefinition(
full_name=scope('MyStruct'),
members={
'member': MemberDefinition(offset=10, cairo_type=TypeFelt()),
},
size=11,
),
}
prime = 2**64 + 13
ap = 100
fp = 200
memory = {
(ap - 2) + 1: 1234,
(ap - 1) + 1: 1000,
(ap - 1) + 1 + 2: 13,
(ap - 1) + 1 + 10: 17,
}
flow_tracking_data = FlowTrackingDataActual(
ap_tracking=RegTrackingData(group=0, offset=4),
reference_ids=references,
)
context = VmConstsContext(
identifiers=IdentifierManager.from_dict(identifier_values),
evaluator=ExpressionEvaluator(prime, ap, fp, memory).eval,
reference_manager=reference_manager,
flow_tracking_data=flow_tracking_data,
memory=memory,
pc=0)
consts = VmConsts(context=context, accessible_scopes=[ScopedName()])
assert consts.x.ref == memory[(ap - 2) + 1]
assert consts.x.typeref.address_ == (ap - 1) + 1
assert consts.x.typeref.member == memory[(ap - 1) + 1 + 10]
with pytest.raises(IdentifierError,
match="'abc' is not a member of 'MyStruct'."):
consts.x.typeref.abc
with pytest.raises(IdentifierError,
match="'SIZE' is not a member of 'MyStruct'."):
consts.x.typeref.SIZE
with pytest.raises(
AssertionError,
match='Cannot change the value of a struct definition.'):
consts.MyStruct = 13
assert consts.MyStruct.member == 10
with pytest.raises(AssertionError,
match='Cannot change the value of a constant.'):
consts.MyStruct.member = 13
assert consts.MyStruct.SIZE == 11
with pytest.raises(AssertionError,
match='Cannot change the value of a constant.'):
consts.MyStruct.SIZE = 13
with pytest.raises(IdentifierError,
match="'abc' is not a member of 'MyStruct'."):
consts.MyStruct.abc
# Test that VmConsts can be used to assign values to references of the form '[...]'.
memory.clear()
consts.x.ref = 1234
assert memory == {(ap - 2) + 1: 1234}
memory.clear()
consts.x.typeref.member = 1001
assert memory == {(ap - 1) + 1 + 10: 1001}
memory.clear()
consts.x.typeref2 = 4321
assert memory == {(ap - 1) + 1: 4321}
consts.x.typeref2.member = 1
assert memory == {
(ap - 1) + 1: 4321,
4321 + 10: 1,
}
with pytest.raises(AssertionError,
match='Cannot change the value of a scope definition'):
consts.x = 1000
with pytest.raises(
AssertionError,
match=
r'x.ref2 \(= \[ap \+ 1\] \+ 0\) does not reference memory and cannot be assigned.',
):
consts.x.ref2 = 1000
with pytest.raises(
AssertionError,
match=
r'x.typeref \(= ap \+ 1\) does not reference memory and cannot be assigned.',
):
consts.x.typeref = 1000
def test_references():
reference_manager = ReferenceManager()
references = {
scope('x.ref'):
reference_manager.get_id(
Reference(
pc=0,
value=parse_expr('[ap + 1]'),
ap_tracking_data=RegTrackingData(group=0, offset=2),
)),
scope('x.ref2'):
reference_manager.get_id(
Reference(
pc=0,
value=parse_expr('[ap + 1] + 0'),
ap_tracking_data=RegTrackingData(group=0, offset=2),
)),
scope('x.ref3'):
reference_manager.get_id(
Reference(
pc=0,
value=parse_expr('ap + 1'),
ap_tracking_data=RegTrackingData(group=0, offset=2),
)),
scope('x.typeref'):
reference_manager.get_id(
Reference(
pc=0,
value=mark_types_in_expr_resolved(
parse_expr('cast(ap + 1, a*)')),
ap_tracking_data=RegTrackingData(group=0, offset=3),
)),
scope('x.typeref2'):
reference_manager.get_id(
Reference(
pc=0,
value=mark_types_in_expr_resolved(
parse_expr('cast([ap + 1], a*)')),
ap_tracking_data=RegTrackingData(group=0, offset=3),
)),
}
identifier_values = {
scope('x.ref'):
ReferenceDefinition(full_name=scope('x.ref'), references=[]),
scope('x.ref2'):
ReferenceDefinition(full_name=scope('x.ref2'), references=[]),
scope('x.ref3'):
ReferenceDefinition(full_name=scope('x.ref3'), references=[]),
scope('x.typeref'):
ReferenceDefinition(full_name=scope('x.typeref'), references=[]),
scope('x.typeref2'):
ReferenceDefinition(full_name=scope('x.typeref2'), references=[]),
scope('a.member'):
MemberDefinition(offset=10, cairo_type=TypeFelt()),
scope('a.scope0.member'):
MemberDefinition(offset=2, cairo_type=TypeFelt()),
}
prime = 2**64 + 13
ap = 100
fp = 200
memory = {
(ap - 2) + 1: 1234,
(ap - 1) + 1: 1000,
(ap - 1) + 1 + 2: 13,
(ap - 1) + 1 + 10: 17,
}
flow_tracking_data = FlowTrackingDataActual(
ap_tracking=RegTrackingData(group=0, offset=4),
reference_ids=references,
)
context = VmConstsContext(
identifiers=IdentifierManager.from_dict(identifier_values),
evaluator=ExpressionEvaluator(prime, ap, fp, memory).eval,
reference_manager=reference_manager,
flow_tracking_data=flow_tracking_data,
memory=memory,
pc=0)
consts = VmConsts(context=context, accessible_scopes=[ScopedName()])
assert consts.x.ref == memory[(ap - 2) + 1]
assert consts.x.typeref.address_ == (ap - 1) + 1
assert consts.x.typeref.member == memory[(ap - 1) + 1 + 10]
with pytest.raises(
NotImplementedError,
match="Expected a member, found 'scope0' which is 'scope'"):
consts.x.typeref.scope0
# Test that VmConsts can be used to assign values to references of the form '[...]'.
memory.clear()
consts.x.ref = 1234
assert memory == {(ap - 2) + 1: 1234}
memory.clear()
consts.x.typeref.member = 1001
assert memory == {(ap - 1) + 1 + 10: 1001}
memory.clear()
consts.x.typeref2 = 4321
assert memory == {(ap - 1) + 1: 4321}
consts.x.typeref2.member = 1
assert memory == {
(ap - 1) + 1: 4321,
4321 + 10: 1,
}
with pytest.raises(AssertionError,
match='Cannot change the value of a scope definition'):
consts.x = 1000
with pytest.raises(
AssertionError,
match=
r'x.ref2 \(= \[ap \+ 1\] \+ 0\) does not reference memory and cannot be assigned.',
):
consts.x.ref2 = 1000
with pytest.raises(
AssertionError,
match=
r'x.typeref \(= ap \+ 1\) does not reference memory and cannot be assigned.',
):
consts.x.typeref = 1000