Error Handling and Recovery in Compilers

class CompilerError(Exception):
    def __init__(self, message, line, column, filename="<stdin>"):
        self.message = message
        self.line = line
        self.column = column
        self.filename = filename

    def __str__(self):
        return f"{self.filename}:{self.line}:{self.column}: error: {self.message}"

class ErrorReporter:
    def __init__(self):
        self.errors = []
        self.warnings = []

    def report(self, error):
        self.errors.append(error)
        print(error)

    def warn(self, message, line, column):
        warning = f"<stdin>:{line}:{column}: warning: {message}"
        self.warnings.append(warning)
        print(warning)

    def has_errors(self):
        return len(self.errors) > 0

reporter = ErrorReporter()
reporter.report(CompilerError("Expected ';' after statement", 5, 12))
reporter.warn("Variable 'x' is assigned but never used", 3, 1)

class PanicModeParser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.pos = 0
        self.reporter = ErrorReporter()
        self.sync_tokens = {";", "}", "end", "else", "fi"}

    def parse(self):
        while self.pos < len(self.tokens):
            try:
                self.parse_statement()
            except CompilerError as e:
                self.reporter.report(e)
                self.synchronize()

    def synchronize(self):
        while self.pos < len(self.tokens):
            token = self.tokens[self.pos]
            if token[0] == "SEPARATOR" and token[1] in self.sync_tokens:
                return
            if token[0] == "KEYWORD":
                return
            self.pos += 1

    def parse_statement(self):
        token = self.peek()
        if token[0] == "IDENTIFIER":
            self.parse_assignment()
        elif token[0] == "KEYWORD" and token[1] == "if":
            self.parse_if()
        else:
            raise CompilerError(
                f"Unexpected token: {token[1]}", 0, 0
            )

    def peek(self):
        return self.tokens[self.pos] if self.pos < len(self.tokens) else ("EOF", "")

    def parse_assignment(self):
        ident = self.consume()
        if self.peek()[0] != "OPERATOR" or self.peek()[1] != "=":
            raise CompilerError("Expected '=' in assignment", 0, 0)
        self.consume()
        self.parse_expression()
        if self.peek()[0] != "SEPARATOR" or self.peek()[1] != ";":
            raise CompilerError("Expected ';' after assignment", 0, 0)
        self.consume()

    def parse_expression(self):
        if self.peek()[0] == "NUMBER":
            self.consume()
        elif self.peek()[0] == "IDENTIFIER":
            self.consume()
        else:
            raise CompilerError("Expected expression", 0, 0)

    def consume(self):
        token = self.peek()
        self.pos += 1
        return token

class ErrorProductionDecorator:
    def __init__(self, parser):
        self.parser = parser

    def parse_expression(self):
        try:
            return self.parser.parse_expression()
        except CompilerError:
            # Check for common pattern: missing operator between operands
            if self.parser.peek()[0] == "NUMBER" and \
               self.parser.tokens[self.parser.pos + 1][0] == "NUMBER":
                raise CompilerError(
                    "Missing operator between numbers. Did you mean '3 + 4'?",
                    self.parser.line, self.parser.column
                )
            raise

def format_error_with_context(source, line, column, message, fix=None):
    lines = source.split("\n")
    context_line = lines[line - 1]
    pointer = " " * (column - 1) + "^"
    result = f"error: {message}\n"
    result += f" --> line {line}, column {column}\n"
    result += f"  {line} | {context_line}\n"
    result += f"     | {pointer}\n"
    if fix:
        result += f"help: {fix}\n"
    return result

source = "let x = 5\nreturn x + "
msg = format_error_with_context(
    source, 2, 12, "Unexpected end of file",
    "Add the missing expression after the '+' operator."
)
print(msg)