def visit(self, node: ast.LetNode, scope: Scope):
for _id, _type, _expr in node.declarations:
try:
# Define and get the var_info
var_info = scope.define_variable(_id,
self.context.get_type(_type))
except SemanticError:
var_info = scope.define_variable(_id, ErrorType())
var_info_node = self.variables[var_info] = VariableInfoNode(
var_info.type, var_info)
expr_node = (self.visit(_expr, scope.create_child())
if _expr is not None else None)
if var_info.type.name == "AUTO_TYPE":
# Create an edge or add an new node only if it is AutoType
if expr_node is not None:
self.graph.add_edge(expr_node, var_info_node)
if expr_node.type.name == "AUTO_TYPE":
self.graph.add_edge(var_info_node, expr_node)
else:
self.graph.add_node(var_info_node)
elif expr_node is not None and expr_node.type.name == "AUTO_TYPE":
self.graph.add_edge(var_info_node, expr_node)
return self.visit(node.expr, scope.create_child())
def visit(self, node: ast.LetNode, scope: Scope):
for i, (_id, _type, _expr) in enumerate(node.declarations):
if _id == "self":
line, column = node.declaration_names_positions[i]
self.errors.append(err.SELF_USED_IN_LET % (line, column))
continue
try:
var_static_type = (self.context.get_type(_type) if
_type != "SELF_TYPE" else self.current_type)
except SemanticError:
line, column = node.declaration_types_positions[i]
self.errors.append(err.UNDEFINED_TYPE % (line, column, _type))
var_static_type = ErrorType()
# if scope.is_local(_id):
# feature = self.current_method or self.current_attribute
# self.errors.append(
# err.LOCAL_ALREADY_DEFINED
# % (node.line, node.column, _id, feature.name)
# )
# else:
scope.define_variable(_id, var_static_type)
expr_type = (self.visit(_expr, scope.create_child())
if _expr is not None else None)
if expr_type is not None and not expr_type.conforms_to(
var_static_type):
self.errors.append(err.INCOMPATIBLE_TYPES %
(node.line, node.column, expr_type.name,
var_static_type.name))
return self.visit(node.expr, scope.create_child())
def visit(self, node: ast.LetNode, scope: Scope):
default = {'String': '', 'Int': 0, 'Bool': False}
for _id, _type, _expr in node.declarations:
instance = self.visit(_expr, scope.create_child()) if _expr is not None else VoidInstance()
if _expr is None and _type in default:
instance = Instance(self.context.get_type(_type), default[_type])
scope.define_variable(_id, instance.type).instance = instance
return self.visit(node.expr, scope.create_child())
def visit(self, node: ast.AttrDeclarationNode, scope: Scope):
if node.id == "self":
self.errors.append(err.SELF_INVALID_ATTRIBUTE_ID %
(node.line, node.column))
try:
attr_type = (self.context.get_type(node.type)
if node.type != "SELF_TYPE" else self.current_type)
except SemanticError:
attr_type = ErrorType()
scope.define_variable("self", self.current_type)
# set the current attribute for analyze the body
# and set the self.current_method variable to None
self.current_attribute = self.current_type.get_attribute(node.id)
self.current_method = None
if node.expr is not None:
expr_type = self.visit(node.expr, scope.create_child())
if not expr_type.conforms_to(attr_type):
line, column = node.expr_position
self.errors.append(
err.INCOMPATIBLE_TYPES %
(line, column, expr_type.name, attr_type.name))
scope.define_variable(node.id, attr_type)
def visit(self, node: ast.SwitchCaseNode, scope: Scope):
self.visit(node.expr, scope)
types = []
visited = set()
for i, (identifier, type_name, expr) in enumerate(node.cases):
new_scope = scope.create_child()
try:
if type_name != "SELF_TYPE":
new_scope.define_variable(identifier,
self.context.get_type(type_name))
else:
self.errors.append(err.INVALID_CASE_TYPE % type_name)
except SemanticError:
new_scope.define_variable(identifier, ErrorType())
line, column = node.cases_positions[i]
self.errors.append(err.UNDEFINED_TYPE_IN_BRANCH %
(line, column, type_name))
# Cannot be dublicate Branches types
if type_name in visited:
line, column = node.cases_positions[i]
self.errors.append(err.DUPLICATE_BARNCH_IN_CASE %
(line, column, type_name))
visited.add(type_name)
types.append(self.visit(expr, new_scope))
return Type.multi_join(types)
def visit(self, node: ast.SwitchCaseNode, scope: Scope):
self.visit(node.expr, scope)
defined_nodes = []
not_defined_nodes = []
case_nodes = []
for _id, _type, _expr in node.cases:
new_scope = scope.create_child()
var_info = new_scope.define_variable(_id,
self.context.get_type(_type))
self.variables[var_info] = VariableInfoNode(
var_info.type, var_info)
case_node = self.visit(_expr, new_scope)
if isinstance(case_node, AtomNode):
defined_nodes.append(case_node)
else:
not_defined_nodes.append(case_node)
case_nodes.append(case_node)
if any(e.type.name == "AUTO_TYPE" for e in case_nodes):
if defined_nodes:
t = Type.multi_join([x.type for x in defined_nodes])
for x in not_defined_nodes:
self.graph.add_edge(AtomNode(t), x)
case_of_node = CaseOfNode(self.context.get_type("AUTO_TYPE"),
case_nodes)
self.graph.add_node(case_of_node)
return case_of_node
return AtomNode(Type.multi_join([e.type for e in case_nodes]))
def visit(self, node: ast.AttrDeclarationNode, scope: Scope):
# Solve the expression of the attribute
expr_node = (self.visit(node.expr, scope.create_child())
if node.expr is not None else None)
# Define attribute in the scope
var_info = scope.define_variable(node.id,
self.context.get_type(node.type))
# Set and get the reference to the variable info node
var_info_node = self.variables[var_info] = VariableInfoNode(
self.context.get_type(node.type), var_info)
if node.type == "AUTO_TYPE":
# Get the reference to the attribute node
attr_node = self.attributes[self.current_type.name, node.id]
# If the expression node is not None then two edges are creates in the graph
if expr_node is not None:
self.graph.add_edge(expr_node, var_info_node)
self.graph.add_edge(expr_node, attr_node)
# Finally a cycle of two nodes is created between var_info_node and attr_node
self.graph.add_edge(var_info_node, attr_node)
self.graph.add_edge(attr_node, var_info_node)
def visit(self, node: ast.ConditionalNode, scope: Scope):
if_node = self.visit(node.if_expr, scope)
if not isinstance(if_node, AtomNode):
self.graph.add_edge(AtomNode(self.context.get_type("Bool")),
if_node)
then_node = self.visit(node.then_expr, scope.create_child())
else_node = self.visit(node.else_expr, scope.create_child())
if isinstance(then_node, AtomNode) and isinstance(else_node, AtomNode):
return AtomNode(then_node.type.join(else_node.type))
conditional_node = ConditionalNode(self.context.get_type("AUTO_TYPE"),
then_node, else_node)
if isinstance(then_node,
AtomNode) and not isinstance(else_node, AtomNode):
self.graph.add_edge(then_node, else_node)
elif not isinstance(then_node, AtomNode) and isinstance(
else_node, AtomNode):
self.graph.add_edge(else_node, then_node)
else:
self.graph.add_edge(then_node, else_node)
self.graph.add_edge(else_node, then_node)
self.graph.add_edge(conditional_node, then_node)
self.graph.add_edge(conditional_node, else_node)
return conditional_node
def visit(self, node: ast.WhileNode, scope: Scope):
condition = self.visit(node.condition, scope)
if condition != self.context.get_type('Bool'):
self.errors.append(err.INCOMPATIBLE_TYPES %
(condition.name, 'Bool'))
self.visit(node.body, scope.create_child())
return self.context.get_type('Object')
def visit(self, node: ast.ProgramNode, scope: Scope = None):
if scope is None:
scope = Scope()
for elem in node.declarations:
self.visit(elem, scope.create_child())
return scope
def visit(self, node: ast.WhileNode, scope: Scope):
condition = self.visit(node.condition, scope)
if condition != self.context.get_type("Bool"):
self.errors.append(
err.INCOMPATIBLE_TYPES %
(node.line, node.column, condition.name, "Bool"))
self.visit(node.body, scope.create_child())
return self.context.get_type("Object")
def visit(self, node: ast.ProgramNode, scope: Scope = None):
if scope is None:
scope = Scope()
for item in node.declarations:
self.visit(item, scope.create_child())
# print(self.graph, '\n')
self.graph.update_dependencies(default_type=self.context.get_type('Object'))
# print(self.graph, '\n')
InferenceTypeSubstitute(self.context, self.errors).visit(node, scope)
def visit(self, node: ast.ClassDeclarationNode, scope: Scope):
self.current_type = self.context.get_type(node.id)
attrs = [feature for feature in node.features if isinstance(feature, ast.AttrDeclarationNode)]
methods = [feature for feature in node.features if isinstance(feature, ast.MethodDeclarationNode)]
for attr in attrs:
self.visit(attr, scope)
for method in methods:
self.visit(method, scope.create_child())
def visit(self, node: ast.LetNode, scope: Scope):
for _id, _type, _expr in node.declarations:
try:
var_static_type = self.context.get_type(
_type) if _type != 'SELF_TYPE' else self.current_type
except SemanticError as e:
self.errors.append(e.text)
var_static_type = ErrorType()
if scope.is_local(_id):
self.errors.append(err.LOCAL_ALREADY_DEFINED %
(_id, self.current_method.name))
else:
scope.define_variable(_id, var_static_type)
expr_type = self.visit(
_expr, scope.create_child()) if _expr is not None else None
if expr_type is not None and not expr_type.conforms_to(
var_static_type):
self.errors.append(err.INCOMPATIBLE_TYPES %
(expr_type.name, var_static_type.name))
return self.visit(node.expr, scope.create_child())
def visit(self, node: ast.AssignNode, scope: Scope):
var_info = scope.find_variable(node.id)
expr_type = self.visit(node.expr, scope.create_child())
if var_info is None:
self.errors.append(err.VARIABLE_NOT_DEFINED %
(node.id, self.current_method.name))
else:
if not expr_type.conforms_to(var_info.type):
self.errors.append(err.INCOMPATIBLE_TYPES %
(expr_type.name, var_info.type.name))
return expr_type
def visit(self, node: ast.AttrDeclarationNode, scope: Scope):
if node.id == 'self':
self.errors.append(err.SELF_INVALID_ATTRIBUTE_ID)
attr_type = self.context.get_type(
node.type) if node.type != 'SELF_TYPE' else self.current_type
if node.expr is not None:
expr_type = self.visit(node.expr, scope.create_child())
if not expr_type.conforms_to(attr_type):
self.errors.append(err.INCOMPATIBLE_TYPES %
(expr_type.name, attr_type.name))
scope.define_variable(node.id, attr_type)
def visit(self, node: ast.AssignNode, scope: Scope):
var_info = scope.find_variable(node.id)
expr_node = self.visit(node.expr, scope.create_child())
if var_info is not None:
if expr_node.type.name != 'AUTO_TYPE' and var_info.type.name == 'AUTO_TYPE':
self.graph.add_edge(expr_node, self.variables[var_info])
elif var_info.type.name != 'AUTO_TYPE' and expr_node.type.name == 'AUTO_TYPE':
self.graph.add_edge(AtomNode(self.context.get_type(var_info.type.name)), expr_node)
elif var_info.type.name == 'AUTO_TYPE' and expr_node.type.name == 'AUTO_TYPE':
# Create a cycle
self.graph.add_edge(expr_node, self.variables[var_info])
self.graph.add_edge(self.variables[var_info], expr_node)
else:
pass
return expr_node
def visit(self, node: ast.SwitchCaseNode, scope: Scope):
self.visit(node.expr, scope)
types = []
for _id, _type, _expr in node.cases:
new_scope = scope.create_child()
try:
if _type != 'SELF_TYPE':
new_scope.define_variable(_id,
self.context.get_type(_type))
else:
self.errors.append(err.INVALID_CASE_TYPE % _type)
except SemanticError as e:
new_scope.define_variable(_id, ErrorType())
self.errors.append(e.text)
types.append(self.visit(_expr, new_scope))
return Type.multi_join(types)
def visit(self, node: ast.AssignNode, scope: Scope):
var_info = scope.find_variable(node.id)
if var_info.name == "self":
self.errors.append(err.SELF_IS_READONLY % (node.line, node.column))
expr_type = self.visit(node.expr, scope.create_child())
if var_info is None:
self.errors.append(
err.UNDEFINED_VARIABLE %
(node.line, node.column, node.id, self.current_method.name))
else:
if not expr_type.conforms_to(var_info.type):
self.errors.append(err.INCOMPATIBLE_TYPES %
(node.line, node.column, expr_type.name,
var_info.type.name))
return expr_type
def visit(self, node: ast.SwitchCaseNode, scope: Scope):
instance = self.visit(node.expr, scope)
if isinstance(instance, VoidInstance):
raise ExecutionError(err.VOID_EXPRESSION)
types = [(i, self.context.get_type(t)) for i, (_, t, _) in enumerate(node.cases)
if instance.type.conforms_to(self.context.get_type(t))]
if not types:
raise ExecutionError(err.CASE_OF_ERROR)
(index, most_conformable_type), *types = types
for i, t in types:
if t.conforms_to(most_conformable_type):
index, most_conformable_type = i, t
child_scope = scope.create_child()
name, typex, expr = node.cases[index]
child_scope.define_variable(name, self.context.get_type(typex)).instance = instance
return self.visit(expr, child_scope)
def visit(self, node: ast.ClassDeclarationNode, scope: Scope):
self.current_type = self.context.get_type(node.id)
attrs = [
feature for feature in node.features
if isinstance(feature, ast.AttrDeclarationNode)
]
methods = [
feature for feature in node.features
if isinstance(feature, ast.MethodDeclarationNode)
]
for attr, attr_owner in self.current_type.all_attributes():
if attr_owner != self.current_type:
scope.define_variable(attr.name, attr.type)
for attr in attrs:
self.visit(attr, scope)
for method in methods:
self.visit(method, scope.create_child())
def visit(self, node: ast.WhileNode, scope: Scope):
self.visit(node.condition, scope)
self.visit(node.body, scope.create_child())
return AtomNode(self.context.get_type("Object"))
def visit(self, node: ast.BlockNode, scope: Scope):
child_scope = scope.create_child()
result_node = None
for expr in node.expressions:
result_node = self.visit(expr, child_scope)
return result_node
def visit(self, node: ast.BlockNode, scope: Scope):
child_scope = scope.create_child()
return_type = ErrorType()
for expr in node.expressions:
return_type = self.visit(expr, child_scope)
return return_type
def visit(self, node: ast.WhileNode, scope: Scope):
while self.visit(node.condition, scope).value:
self.visit(node.body, scope.create_child())
return VoidInstance()
def visit(self, node: ast.ConditionalNode, scope: Scope):
if_instance = self.visit(node.if_expr, scope)
if if_instance.value:
return self.visit(node.then_expr, scope.create_child())
return self.visit(node.else_expr, scope.create_child())
