Merge pull request #110 from Jodus-Melodus/better-errors

Better errors

ast.json

@@ -10,19 +10,6 @@
                 "value": 5
             },
             "constant": "False"
-        },
-        {
-            "kind": "callExpression",
-            "arguments": [
-                {
-                    "kind": "stringLiteral",
-                    "value": "Hello world"
-                }
-            ],
-            "caller": {
-                "kind": "identifier",
-                "symbol": "output"
-            }
         }
     ]
 }

backend/Interpreter.py

@@ -657,7 +657,7 @@ def evaluate_delete_statement(self, delete_statement: DeleteNode, env: Environme
         env.delete_variable(delete_statement.variable)
         return NullValue()
 
-    def evaluate(self, astNode, env: Environment) -> NullValue | IntegerValue | ObjectValue | ArrayValue | StringValue | None:
+    def evaluate(self, astNode: ASTNode, env: Environment) -> RuntimeValue | None:
         if isinstance(astNode, (str, float, int, Error)):
             return astNode
         match astNode.kind:

frontend/Error.py

@@ -1,14 +1,11 @@
 import os
 
 class Error:
-    def __init__(self, file:str="", column:int=0, line:int=0) -> None:
-        self.file = os.path.basename(file)
+    def __init__(self, file_path:str="", column:int=0, line:int=0) -> None:
+        self.file_path = os.path.basename(file_path)
         self.column = column
         self.line = line
 
-    def warning_message(self) -> str:
-        return ""
-
     def __repr__(self) -> str:
         return ""
 
@@ -21,157 +18,110 @@ def error_arrows(self) -> str:
         out += '^'
         return out + '\n'
 
-###########################################################################################################
-
 class SyntaxError(Error):
-    def __init__(self, file:str, stage: str, msg: str, column: int, line: int) -> None:
-        super().__init__(file, column, line)
+    def __init__(self, file_path:str, stage: str, msg: str, column: int, line: int) -> None:
+        super().__init__(file_path, column, line)
         self.stage = stage
         self.msg = msg
         self.type = "syntaxError"
 
     def __repr__(self) -> str:
         return f"""{self.error_arrows()}
-[Syntax Error] Ln {self.line}, Col {self.column} in {self.file}:
-{self.msg}
+[Syntax Error] Ln {self.line}, Col {self.column} in {self.file_path}: {self.msg}
 """
 
-    def warning_message(self) -> str:
-        return f"[Syntax Error] Ln {self.line}, Col {self.column} in {self.file}: {self.msg}"
-###########################################################################################################
-
 class NameError(Error):
-    def __init__(self, file:str, stage: str, name: str, column: int, line: int) -> None:
-        super().__init__(file, column, line)
+    def __init__(self, file_path:str, stage: str, name: str, column: int, line: int) -> None:
+        super().__init__(file_path, column, line)
         self.stage = stage
         self.name = name
         self.type = "nameError"
 
     def __repr__(self) -> str:
         return f"""{self.error_arrows()}
-[Name Error] Ln {self.line}, Col {self.column} in {self.file}:
-"{self.name}" is not defined
+[Name Error] Ln {self.line}, Col {self.column} in {self.file_path}: "{self.name}" is not defined
 """
-    def warning_message(self) -> str:
-        return f"[Name Error] Ln {self.line}, Col {self.column} in {self.file}: '{self.name}' is not defined"
-###########################################################################################################
 
 class InvalidCharacterError(Error):
-    def __init__(self, file:str, stage: str, character: str, column: int, line: int) -> None:
-        super().__init__(file, column, line)
+    def __init__(self, file_path:str, stage: str, character: str, column: int, line: int) -> None:
+        super().__init__(file_path, column, line)
         self.stage = stage
         self.character = character
         self.type = "invalidCharacterError"
 
     def __repr__(self) -> str:
         return f"""{self.error_arrows()}
-[Invalid Character Error] Ln {self.line}, Col {self.column} in {self.file}:
-"{self.character}" is not a valid character
+[Invalid Character Error] Ln {self.line}, Col {self.column} in {self.file_path}: "{self.character}" is not a valid character
 """
 
-    def warning_message(self) -> str:
-        return f"[Invalid Character Error] Ln {self.line}, Col {self.column} in {self.file}: '{self.character}' is not a valid character"
-
-###########################################################################################################
-
 class NotImplementedError(Error):
-    def __init__(self, file:str, stage: str, msg: str, column: int, line: int) -> None:
-        super().__init__(file, column, line)
+    def __init__(self, file_path:str, stage: str, msg: str, column: int, line: int) -> None:
+        super().__init__(file_path, column, line)
         self.stage = stage
         self.msg = msg
         self.type = "notImplementedError"
 
     def __repr__(self) -> str:
         return f"""{self.error_arrows()}
-[Not Implemented Error] Ln {self.line}, Col {self.column} in {self.file}:
-"{self.msg}" is not yet Implemented
+[Not Implemented Error] Ln {self.line}, Col {self.column} in {self.file_path}: "{self.msg}" is not yet Implemented
 """
-
-    def warning_message(self) -> str:
-        return f"[Not Implemented Error] Ln {self.line}, Col {self.column} in {self.file}: '{self.msg}' is not yet Implemented"
-###########################################################################################################
 
 class KeyError(Error):
-    def __init__(self, file:str, stage: str, key, obj, column: int, line: int) -> None:
-        super().__init__(file, column, line)
+    def __init__(self, file_path:str, stage: str, key, obj, column: int, line: int) -> None:
+        super().__init__(file_path, column, line)
         self.stage = stage
         self.key = key
         self.obj = obj
         self.type = "keyError"
 
     def __repr__(self) -> str:
         return f"""{self.error_arrows()}
-[Key Error] Ln {self.line}, Col {self.column} in {self.file}:
-"{self.key}" is not a valid key for "{self.obj}"
+[Key Error] Ln {self.line}, Col {self.column} in {self.file_path}: "{self.key}" is not a valid key for "{self.obj}"
 """
-
-    def warning_message(self) -> str:
-        return f"[Key Error] Ln {self.line}, Col {self.column} in {self.file}: '{self.key}'' is not a valid key for '{self.obj}'"
-###########################################################################################################
 
 class TypeError(Error):
-    def __init__(self, file:str, stage: str, msg:str, column: int, line: int) -> None:
-        super().__init__(file, column, line)
+    def __init__(self, file_path:str, stage: str, msg:str, column: int, line: int) -> None:
+        super().__init__(file_path, column, line)
         self.stage = stage
         self.msg = msg
         self.type = "typeError"
 
     def __repr__(self) -> str:
         return f"""{self.error_arrows()}
-[Type Error] Ln {self.line}, Col {self.column} in {self.file}:
-{self.msg}
+[Type Error] Ln {self.line}, Col {self.column} in {self.file_path}: {self.msg}
 """
-
-    def warning_message(self) -> str:
-        return f"[Type Error] Ln {self.line}, Col {self.column} in {self.file}: {self.msg}"
-###########################################################################################################
 
 class ZeroDivisionError(Error):
-    def __init__(self, file:str, stage: str, column: int, line: int) -> None:
-        super().__init__(file, column, line)
+    def __init__(self, file_path:str, stage: str, column: int, line: int) -> None:
+        super().__init__(file_path, column, line)
         self.stage = stage
         self.type = "zeroDivisionError"
 
     def __repr__(self) -> str:
         return f"""{self.error_arrows()}
-[Zero Division Error] Ln {self.line}, Col {self.column} in {self.file}:
-Cannot divide by zero
+[Zero Division Error] Ln {self.line}, Col {self.column} in {self.file_path}: Cannot divide by zero
 """
-
-    def warning_message(self) -> str:
-        return f"[Zero Division Error] Ln {self.line}, Col {self.column} in {self.file}: Cannot divide by zero"
-###########################################################################################################
 
-class FileNotFoundError(Error):
-    def __init__(self, file:str, stage: str, file_: str, column: int, line: int) -> None:
-        super().__init__(file, column, line)
+class File_pathNotFoundError(Error):
+    def __init__(self, file_path:str, stage: str, file_path_: str, column: int, line: int) -> None:
+        super().__init__(file_path, column, line)
         self.stage = stage
-        self.file_ = file_
-        self.type = "fileNotFoundError"
+        self.file_path_ = file_path_
+        self.type = "file_pathNotFoundError"
 
     def __repr__(self) -> str:
         return f"""{self.error_arrows()}
-[File Not Found Error] Ln {self.line}, Col {self.column} in {self.file}:
-File "{self.file_}" not found
+[File_path Not Found Error] Ln {self.line}, Col {self.column} in {self.file_path}: File_path "{self.file_path_}" not found
 """
-
-    def warning_message(self) -> str:
-        return f"[File Not Found Error] Ln {self.line}, Col {self.column} in {self.file}: File '{self.file_}' not found"
-
-###########################################################################################################
 
 class ValueError(Error):
-    def __init__(self, file: str, stage: str, value, column: int, line: int) -> None:
-        super().__init__(file, column, line)
+    def __init__(self, file_path: str, stage: str, value, column: int, line: int) -> None:
+        super().__init__(file_path, column, line)
         self.stage = stage
         self.value = value
         self.type = "valueError"
 
     def __repr__(self) -> str:
         return f"""{self.error_arrows()}
-[Value Error] Ln {self.line}, Col {self.column} in {self.file}:
-Invalid value : "{self.value}"
-"""
-
-    def warning_message(self) -> str:
-        return f"[Value Error] Ln {self.line}, Col {self.column} in {self.file}: Invalid value : '{self.value}'"
+[Value Error] Ln {self.line}, Col {self.column} in {self.file_path}: Invalid value : "{self.value}"
+"""

frontend/Lexer.py

@@ -46,7 +46,7 @@ def __init__(self, source_code: str, file_path:str=''):
         self.column = 1
 
     def __str__(self) -> str:
-        return 'Lexer'
+        return "Lexer"
 
     def eat(self) -> None:
         self.column += 1
@@ -281,7 +281,7 @@ def process_variables_and_identifiers(self):
 
         while len(self.source_code) > 0:
             char = self.get()
-            if char in f'{ALPHABET}1234567890':
+            if char in f'{ALPHABET}{DIGITS}':
                 name += char
             else:
                 break

frontend/Parser.py

@@ -3,8 +3,8 @@
 from frontend.Error import *
 
 class Parser:
-    def __init__(self, tokens: list, filePath:str="") -> None:
-        self.file_path = filePath
+    def __init__(self, tokens: list, file_path:str="") -> None:
+        self.file_path = file_path
         self.tokens = tokens
         self.program = ProgramNode([])
         self.conditional_operators = (TT.equal, TT.not_equal, TT.greater_than, TT.less_than, TT.greater_than_equal, TT.less_than_equal, TT._and, TT._or)
@@ -473,10 +473,13 @@ def parse_function_declaration(self) -> None:
 
     def parse_variable_declaration(self) -> None:
         datatype = self.eat().type
+
         if self.get().type == TT.eof:
             return SyntaxError(self.file_path, self, "Expected an identifier", self.column, self.line)
+
         identifier = self.eat().value
         constant = bool(identifier.isupper())
+
         if self.get().type != TT.assignment_operator:
             if self.get().type in (TT.eof, TT.lineend):
                 self.eat()
@@ -486,10 +489,14 @@ def parse_variable_declaration(self) -> None:
                 return SyntaxError(self.file_path, self, "Expected a variable declaration", self.column, self.line)
         else:
             self.eat()
-            statement = self.parse_statement()
-            if isinstance(statement, Error):
-                return statement
-            return VariableDeclarationExpressionNode(datatype, identifier, statement, constant, self.line, self.column)
+
+            if self.get().type in [TT.int_value, TT.string_value, TT.real_value, TT.identifier]:
+                statement = self.parse_statement()
+                if isinstance(statement, Error):
+                    return statement
+                return VariableDeclarationExpressionNode(datatype, identifier, statement, constant, self.line, self.column)
+            else:
+                return SyntaxError(self.file_path, self, "Expected a value", self.column, self.line)
 
     def parse_assignment_expression(self) -> None:
         left = self.parse_object_expression()

phIDE.py

@@ -719,6 +719,7 @@ def key_press_update(self, event) -> None:
         if editor := self.current_tab:
             self.line, self.column = editor.index("insert").split(".")
             self.status_bar.configure(text=f"Ln {self.line}, Col {self.column}")
+
             current_code = editor.get("0.0", "end")
             self.get_warnings(editor, current_code)
 
@@ -735,36 +736,34 @@ def get_warnings(self, editor : ctk.CTkTextbox, current_code: str):
 
         self.warnings.configure(state="normal")
         self.warnings.delete("0.0", "end")
-        self.warnings.configure(state="disabled")
 
         parser_warnings = shell.incremental_parsing(current_code, self.current_path)
 
         if isinstance(parser_warnings, list) and len(parser_warnings) > 0 and isinstance(parser_warnings[0], Error):
             for warning in parser_warnings:
                 warning: Error = warning
                 line = warning.line
-                editor.tag_add("warning", f"{line}.0", f"{line}.end")
-                self.warnings.configure(state="normal")
-                self.warnings.insert("end", warning.warning_message() + '\n')
-                self.warnings.configure(state="disabled")
 
-        # Update warning tab's name to match total warnings
-        warnings = self.warnings.get("0.0", "end").strip().split("\n")
-        tabs = list(self.bottom_tabview._tab_dict.keys())
+                program_line = editor.get(f"{line}.0", f"{line}.end")
+
+                editor.tag_add("warning", f"{line}.0", f"{line}.end")
+                self.warnings.insert("end", f"{program_line}\n{repr(warning)}\n")
 
-        if (len(warnings) > 0) and (warnings[0] != ""):
-            new_name = f"Warnings({len(warnings)})"
+            # Update warning tab's name to match total warnings
+            new_name = f"Warnings({len(parser_warnings)})"
         else:
+            editor.tag_remove("warning", "0.0", "end")
             new_name = "Warnings"
 
+        self.warnings.configure(state="disabled")
+        tabs = list(self.bottom_tabview._tab_dict.keys())
         current_name = tabs[1]
 
         if new_name not in self.bottom_tabview._tab_dict.keys():
             self.bottom_tabview.rename(current_name, new_name)
 
     def editor_press(self, _=None) -> None:
         if editor := self.current_tab:
-            editor.tag_remove("warning", "0.0", "end")
             name = self.center_tabview.get()
             current_code = editor.get("0.0", "end")
 
@@ -788,11 +787,12 @@ def mouse_click_update(self, _=None) -> None:
     def highlight_selected(self, _=None) -> None:
         if not (editor := self.current_tab):
             return
-        text = editor.get("0.0", "end").split("\n")
+
         if editor.tag_ranges("sel"):
-            w = editor.get(ctk.SEL_FIRST, ctk.SEL_LAST)
-            word = re.escape(w)
-            pattern = f"({word})"
+            word = editor.get(ctk.SEL_FIRST, ctk.SEL_LAST)
+            pattern = f"({re.escape(word)})"
+            text = editor.get("0.0", "end").split("\n")
+
             for ln, line in enumerate(text):
                 matches = [(match.start(), match.end())
                            for match in re.finditer(pattern, line)]