errors.py

"""
voidc.errors
============
Central diagnostics engine used by every compiler stage (lexer, parser,
semantic analyzer, type checker, codegen). Modeled loosely on rustc/clang
style diagnostics: each message carries a severity, a source span, a
human message, and an optional "help" hint.

Design goals:
  * Never throw a raw Python exception for a *user* source error -- always
    go through `Diagnostics.error()/warn()` so messages are uniform and
    batched (a compiler that stops at the first typo is annoying to use).
  * Fatal internal errors (compiler bugs) raise `InternalCompilerError`
    instead, which is distinct from a `VoidCompileError` (user-caused).
"""

from dataclasses import dataclass, field
from enum import Enum, auto
from typing import List, Optional


class Severity(Enum):
    ERROR = auto()
    WARNING = auto()
    NOTE = auto()


@dataclass
class Diagnostic:
    severity: Severity
    message: str
    file: str
    line: int
    col: int
    help: Optional[str] = None
    code: Optional[str] = None  # e.g. "E0101" for machine-searchable errors

    def render(self, source_lines: Optional[List[str]] = None) -> str:
        tag = {Severity.ERROR: "error", Severity.WARNING: "warning", Severity.NOTE: "note"}[self.severity]
        code = f"[{self.code}] " if self.code else ""
        out = f"{self.file}:{self.line}:{self.col}: {tag}: {code}{self.message}"
        if source_lines and 0 < self.line <= len(source_lines):
            src = source_lines[self.line - 1].rstrip("\n")
            pointer = " " * max(self.col - 1, 0) + "^"
            out += f"\n    {src}\n    {pointer}"
        if self.help:
            out += f"\n    help: {self.help}"
        return out
    

class VoidCompileError(Exception):
    """Raised to unwind out of a stage once errors are unrecoverable."""
    pass


class InternalCompilerError(Exception):
    """A bug in voidc itself, as opposed to a user source error."""
    pass


class Diagnostics:
    def __init__(self, filename: str, source: str = ""):
        self.filename = filename
        self.source_lines = source.splitlines() if source else []
        self.items: List[Diagnostic] = []
        self.sources = {}     

    def error(self, message, line, col, help=None, code=None, file=None):
        self.items.append(
        Diagnostic(
            Severity.ERROR,
            message,
            file or self.filename,
            line,
            col,
            help,
            code
        )
        )

    def warn(self, message, line, col, help=None, code=None, file=None):
        self.items.append(
        Diagnostic(
            Severity.WARNING,
            message,
            file or self.filename,
            line,
            col,
            help,
            code
        )
        )

    def note(self, message, line, col, help=None):
        self.items.append(Diagnostic(Severity.NOTE, message, self.filename, line, col))

    @property
    def has_errors(self) -> bool:
        return any(d.severity == Severity.ERROR for d in self.items)

    def error_count(self) -> int:
        return sum(1 for d in self.items if d.severity == Severity.ERROR)

    def warning_count(self) -> int:
        return sum(1 for d in self.items if d.severity == Severity.WARNING)

    def dump(self) -> str:
        return "\n".join(d.render(self.source_lines) for d in self.items)

    def raise_if_errors(self):
        if self.has_errors:
            raise VoidCompileError(self.dump())
    def add_source(self, filename, source):
        self.sources[filename] = source