「错误恢复与诊断」

@dataclass
class Span:
    file: str
    line: int
    col: int
    length: int

@dataclass
class Diagnostic:
    severity: str            # error / warning / note
    code: str                # E0308
    message: str
    span: Span
    suggestions: list[str] = field(default_factory=list)

def render(diag, source):
    line = source[diag.span.line - 1]
    caret = " " * (diag.span.col - 1) + "^" * diag.span.length
    return (f"{diag.code}: {diag.message}\n"
            f" --> {diag.span.file}:{diag.span.line}:{diag.span.col}\n"
            f"{diag.span.line:>4} | {line}\n"
            f"     | {caret}")

class ErrorRecoveringParser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.pos = 0
        self.errors = []

    def sync(self, stop_set):
        """panic 模式: 跳过直到同步 token。"""
        while self.pos < len(self.tokens):
            t = self.tokens[self.pos]
            if t.kind in stop_set or t.kind == "EOF":
                return
            self.pos += 1

    def expect(self, kind):
        tok = self.peek()
        if tok.kind == kind:
            self.pos += 1
            return tok
        self.errors.append(
            Diagnostic("error", "E0001", f"expected {kind}",
                       tok.span))
        self.sync({";", "}", "EOF"})     # 跳到同步点
        return None                       # 返回占位节点

class ErrorType:      # 特殊标记: 类型未知且已报错
    _singleton = None

ERROR_TYPE = ErrorType()

class SemAnalyzer:
    def __init__(self):
        self.gamma = {}
        self.errors = []

    def visit_binop(self, node):
        t1 = self.visit(node.left)
        t2 = self.visit(node.right)
        if t1 is ERROR_TYPE or t2 is ERROR_TYPE:
            return ERROR_TYPE           # 不叠加报错
        if t1 != t2:
            self.errors.append(Diagnostic(
                "error", "E0308",
                f"cannot add `{t1}` and `{t2}`", node.span))
            return ERROR_TYPE
        return t1

    def visit_var(self, node):
        if node.name not in self.gamma:
            self.errors.append(Diagnostic(
                "error", "E0425", f"undefined name `{node.name}`",
                node.span))
            self.gamma[node.name] = ERROR_TYPE  # 占位, 去重
        return self.gamma[node.name]

# 一条 lint 规则的骨架: 匹配 AST 模式并产出诊断
class LintRule:
    name = "no-constant-condition"
    severity = "warning"

    def check(self, node, ctx):
        if (node.kind == "if"
                and node.cond.kind == "bool_lit"):
            ctx.report(
                Diagnostic("warning", "C001",
                           "condition is always true/false",
                           node.cond.span))

# 数据流检查: 未初始化变量 (简化)
def uninitialized_use(cfg):
    defined = set()
    for block in cfg.blocks:
        for stmt in block:
            if stmt.is_def: defined.add(stmt.var)
            elif stmt.var not in defined:
                yield Diagnostic("warning", "C002",
                                 f"`{stmt.var}` may be uninitialized",
                                 stmt.span)

class IncrementalDriver:
    def __init__(self, cache_dir):
        self.cache_dir = cache_dir
        self.fingerprints = {}     # file -> hash

    def needs_rebuild(self, source_file):
        new = hash_file(source_file)
        old = self.fingerprints.get(source_file)
        return new != old

    def build(self, files):
        dirty = [f for f in files if self.needs_rebuild(f)]
        if not dirty:
            return "up to date"
        # 只重新编译变更文件, 未变者复用缓存的 .o
        for f in dirty:
            self.compile(f)          # 产出缓存并更新指纹
        self.link(files)

@dataclass
class FixIt:
    span: Span
    replacement: str

class Suggest:
    """常见错误的修复建议生成 (示例)。"""
    def on_type_mismatch(self, found, expected, span):
        if found == "f64" and expected == "u32":
            return FixIt(span, f"({span.text} as u32)")
        return None

    def on_typo(self, name, candidates):
        closest = min(candidates, key=levenshtein(name))
        return FixIt(name_span, closest)

# 自动应用修复: 直接改源文本
def apply_fixits(source, diagnostics):
    out = []
    pos = 0
    for diag in diagnostics:
        fix = diag.fixit
        if fix is None:
            continue
        out.append(source[pos:fix.span.start])
        out.append(fix.replacement)
        pos = fix.span.end
    out.append(source[pos:])
    return "".join(out)

# 概念: 增量重分析 + 缓存, 支撑 IDE 实时诊断
class LanguageService:
    def __init__(self, compiler):
        self.cache = {}            # file -> (hash, parse_tree)

    def on_change(self, uri, new_text):
        if self.cache[uri][0] == hash(new_text):
            return []              # 内容未变, 无新诊断
        tree = self.compiler.parse(new_text)
        self.cache[uri] = (hash(new_text), tree)
        diags = self.compiler.analyze(uri, tree)
        return diags               # 推给编辑器

    def completion(self, uri, pos):
        tree = self.cache[uri][1]
        scope = self.compiler.scope_at(tree, pos)
        return [name for name in scope.symbols]