def assign(self, scope: dict, tree: TypeTree, value):
if tree.data == "object":
self.assert_(isinstance(value, VolpeObject),
"can only destructure object", tree)
self.assert_(
len(tree.children) == len(value.type_dict),
"only full deconstruction is allowed", tree)
used = set()
for i, child in enumerate(tree.children):
key, attribute = get_obj_key_value(child, i)
self.assert_(key in value.type_dict,
f"object doesn't have attribute {key}", child)
self.assert_(key not in used, f"{key} has already been used",
child)
used.add(key)
assign(self, scope, attribute, value.type_dict[key])
elif tree.data == "attribute":
self.assert_(
self.visit(tree) == value, "wrong type in attribute assignment",
tree)
elif tree.data == "array":
self.assert_(isinstance(value, VolpeArray),
"can only destructure array", tree)
self.assert_(value.count == len(tree.children),
"array has wrong length", tree)
for child in tree.children:
assign(self, scope, child, value.element)
elif tree.data == "array_index":
self.assert_(
self.visit(tree) == value, "wrong type in array assignment", tree)
else:
self.assert_(tree.data == "symbol", f"cannot assign to {tree.data}",
tree)
scope[tree.children[0].value] = value
tree.return_type = value
def escaped_character(tree: TypeTree):
# let Python parse the escaped character (guaranteed ascii by lark)
evaluated = eval(f"{tree.children[0]}")
return tree.return_type(ord(evaluated))
def character(tree: TypeTree):
return tree.return_type(ord(tree.children[0].value[1]))
def integer(tree: TypeTree):
return tree.return_type(int(tree.children[0].value))
def visit(self, tree: TypeTree):
tree.return_type = getattr(self, tree.data)(tree)
if tree.return_type is None:
tree.return_type = int1
return tree.return_type