cyclic dependency fixed

src/coolc.py

@@ -9,7 +9,7 @@
 print('Copyright (c) 2021: Yasmin Cisneros Cimadevila & Jessy Gigato Izquierdo')
 
 def run():
-    sp = subprocess.run(['python3.9', 'utils/pipeline.py', 'final-execution', input_file, output_file], capture_output=True, timeout=100) 
+    sp = subprocess.run(['python', 'utils/pipeline.py', 'final-execution', input_file, output_file], capture_output=True, timeout=100) 
     dcode = sp.stdout.decode()
     print(dcode)
     exit(sp.returncode)

src/utils/pipeline.py

@@ -6,7 +6,7 @@
 from cool_grammar import parser, errors as parser_errors
 from cool_lexer import lexer, lexer_errors
 from utils.ast_nodes import Token
-from utils.cyclic_dependency import CyclicDependency
+from utils.cyclic_dependency import CyclicDependency, MethodChecker
 from utils.formatter import Formatter, CodeBuilder
 from utils.semantic import Context, Scope
 from utils.inference import InferenceTypeChecker
@@ -272,6 +272,7 @@ def final_execution(program_file, program_file_out, debug: bool = False, verbose
                 print_errors(item)
             exit(1)
         CyclicDependency(context, errors)
+        MethodChecker(context, errors, program).visit(ast)
         InferenceTypeChecker(context, errors, program).visit(ast, scope)
 
         TypeChecker(context, errors, program).visit(ast, scope)

src/utils/utils/cyclic_dependency.py

@@ -1,4 +1,6 @@
 from .semantic import Context, SemanticError
+from utils import visitor
+from utils import ast_nodes as ast
 
 class CyclicDependency:
     def __init__(self, context: Context, errors):
@@ -47,3 +49,76 @@ def __is_cyclic__(self):
         if dfs != len(self.vertex) - 2:
             raise SemanticError('Existe un ciclo en el árbol de dependencias')
 
+
+class MethodChecker:
+    def __init__(self, context: Context, errors, program):
+        self.context: Context = context
+        self.current_type = None
+        self.errors = errors
+        self.program = program
+
+    def get_tokencolumn(self, str, pos):
+        column = 1
+        temp_pos = pos
+        while str[temp_pos] != '\n':
+            if temp_pos == 0: break
+            temp_pos -= 1
+            column += 1
+        return column if column > 1 else 2
+
+    @visitor.on("node")
+    def visit(self, node):
+        pass
+
+    @visitor.when(ast.ProgramNode)
+    def visit(self, node: ast.ProgramNode):
+        for data in node.class_list:
+            self.visit(data)
+
+    @visitor.when(ast.ClassDecNode)
+    def visit(self, node: ast.ClassDecNode):
+        self.current_type = self.context.get_type(node.name)
+
+        for data in node.data:
+            if isinstance(data, ast.MethodDecNode):
+                self.visit(data)
+
+    @visitor.when(ast.AttributeDecNode)
+    def visit(self, node: ast.AttributeDecNode):
+        try:
+            attribute, owner = self.current_type.parent.get_attribute(node.name)
+            line, lexpos = node.type_pos
+            self.errors.append(f'({line}, {self.get_tokencolumn(self.program, lexpos)}) - SemanticError: Attribute "{attribute.name}" already defined in "{owner.name}", attributes cannot be overridden')
+        except SemanticError:
+            pass
+
+    @visitor.when(ast.MethodDecNode)
+    def visit(self, node: ast.MethodDecNode):
+        # TODO: Change the comparison overriding
+        current_method = self.current_type.get_method(node.name)
+        try:
+            original_method, _ = self.current_type.parent.get_method(
+                node.name, owner=True
+            )
+
+            current_count = len(current_method.param_types)
+            original_count = len(original_method.param_types)
+            if current_count != original_count:
+                self.errors.append(f'({node.line}, {self.get_tokencolumn(self.program, node.lexpos)}) - SemanticError: In redefinded method "{node.name}", param type "{original_count}" is different from original param type "{current_count}"')
+
+            counter = min(original_count, current_count)
+            for i in range(counter):
+                current_type = current_method.param_types[i].name
+                original_type = original_method.param_types[i].name
+                if current_type != original_type:
+                    line, lexpos = node.p_types_pos[i]
+                    self.errors.append(self.errors.append(f'({line}, {self.get_tokencolumn(self.program, lexpos)}) - SemanticError: In redefinded method "{node.name}", param type "{current_type}" is different from original param type "{original_method}"'))
+
+            current_return_type = current_method.return_type.name
+            original_return_type = original_method.return_type.name
+            if current_return_type != original_return_type:
+                line, lexpos = node.r_types_pos
+                self.errors.append(f'({line}, {self.get_tokencolumn(self.program, lexpos)}) - SemanticError: In redefinded method "{node.name}", return type "{current_return_type}" is different from original return type "{original_return_type}"')
+        except SemanticError:
+            pass
+

src/utils/utils/semantic.py

@@ -73,14 +73,14 @@ def define_attribute(self, name: str, typex):
         else:
             raise SemanticError(f'Attribute "{name}" is already defined in {self.name}.')
 
-    def get_method(self, name: str):
+    def get_method(self, name: str, owner=False):
         try:
-            return self.methods[name]
+            return self.methods[name] if not owner else (self.methods[name], self)
         except KeyError:
             if self.parent is None:
                 raise SemanticError(f'Method "{name}" is not defined in {self.name}.')
             try:
-                return self.parent.get_method(name)
+                return self.parent.get_method(name, owner)
             except SemanticError:
                 raise SemanticError(f'Method "{name}" is not defined in {self.name}.')
 

src/utils/utils/type_analysis.py

@@ -222,13 +222,13 @@ def visit(self, node: ast.MethodDecNode):
                 param_types.append(self.context.get_type(typex))
             except SemanticError:
                 param_types.append(ErrorType())
-                line, lexpos = node.p_types_positions[i]
+                line, lexpos = node.p_types_pos[i]
                 self.errors.append(f'({line}, {self.get_tokencolumn(self.program, lexpos)}) - TypeError: Undefined param type "{typex}" in method "{node.name}", in class "{self.current_type.name}"')
         try:
             return_type = self.context.get_type(node.type)
         except SemanticError:
             return_type = ErrorType()
-            line, lexpos = node.r_types_position
+            line, lexpos = node.r_types_pos
             self.errors.append(f'({line}, {self.get_tokencolumn(self.program, lexpos)}) - TypeError: Undefined return type "{node.type}" in method "{node.name}", in class "{self.current_type.name}"')
         try:
             self.current_type.define_method(node.name, param_names, param_types, return_type)
@@ -340,24 +340,24 @@ def visit(self, node: ast.LetNode, scope: Scope):
             if id_ == 'self':
                 l, lp = node.dec_names_pos[pos]
                 self.errors.append(f'({l}, {lp}) - SemanticError: "self" cannot be bound in a "let" expression')
-            else:
-                try:
-                    if type_ != "SELF_TYPE": 
-                        var_type = self.context.get_type(type_)
-                    else: 
-                        var_type = self.current_type
-                    
-                except SemanticError:
-                    line, lexpos = node.dec_types_pos[pos]
-                    self.errors.append(f'({line}, {self.get_tokencolumn(self.program, lexpos)}) - TypeError: Type "{type_}" is not defined')
-                    var_type = ErrorType()
+                continue
+            try:
+                if type_ != "SELF_TYPE": 
+                    var_type = self.context.get_type(type_)
+                else: 
+                    var_type = self.current_type
+
+            except SemanticError:
+                line, lexpos = node.dec_types_pos[pos]
+                self.errors.append(f'({line}, {self.get_tokencolumn(self.program, lexpos)}) - TypeError: Type "{type_}" is not defined')
+                var_type = ErrorType()
             scope.define_variable(id_, var_type)
 
             expr_type = None
             if exp is not None:
                 expr_type = self.visit(exp, scope.create_child())
             if expr_type is not None and not expr_type.conforms_to(var_type):
-                self.errors.append(f'({node.line}, {self.get_tokencolumn(self.program, self.lexpos)}) - TypeError: Cannot convert "{expr_type.name}" into "{var_type.name}".')
+                self.errors.append(f'({node.line}, {self.get_tokencolumn(self.program, node.lexpos)}) - TypeError: Cannot convert "{expr_type.name}" into "{var_type.name}".')
 
             # if exp is not None:
             #     return_type = self.visit(exp, sc)