slige-mirror/compiler/ast/visitor.ts

import { exhausted } from "../util.ts";
import {
    AnonStructTy,
    ArrayExpr,
    ArrayTy,
    AssignStmt,
    BinaryExpr,
    BindPat,
    BoolExpr,
    BreakStmt,
    CallExpr,
    CForExpr,
    DerefExpr,
    ElemExpr,
    EnumItem,
    Expr,
    ExprStmt,
    FieldExpr,
    File,
    FnItem,
    ForExpr,
    GroupExpr,
    Ident,
    IfExpr,
    IndexExpr,
    IntExpr,
    Item,
    ItemStmt,
    LetStmt,
    LoopExpr,
    ModBlockItem,
    ModFileItem,
    Pat,
    Path,
    PtrTy,
    RefExpr,
    RefTy,
    RepeatExpr,
    ReturnStmt,
    SliceTy,
    Stmt,
    StringExpr,
    StructExpr,
    StructItem,
    TupleTy,
    Ty,
    TypeAliasItem,
    UnaryExpr,
    UseItem,
    WhileExpr,
} from "./ast.ts";

export type VisitRes = "stop" | void;

type R = VisitRes;
type PM = unknown[];

export interface Visitor<
    P extends PM = [],
> {
    visitFile?(file: File, ...p: P): R;

    visitStmt?(stmt: Stmt, ...p: P): R;
    visitErrorStmt?(stmt: Stmt, ...p: P): R;
    visitItemStmt?(stmt: Stmt, kind: ItemStmt, ...p: P): R;
    visitLetStmt?(stmt: Stmt, kind: LetStmt, ...p: P): R;
    visitReturnStmt?(stmt: Stmt, kind: ReturnStmt, ...p: P): R;
    visitBreakStmt?(stmt: Stmt, kind: BreakStmt, ...p: P): R;
    visitContinueStmt?(stmt: Stmt, ...p: P): R;
    visitAssignStmt?(stmt: Stmt, kind: AssignStmt, ...p: P): R;
    visitExprStmt?(stmt: Stmt, kind: ExprStmt, ...p: P): R;

    visitItem?(item: Item, ...p: P): R;
    visitErrorItem?(item: Item, ...p: P): R;
    visitModBlockItem?(item: Item, kind: ModBlockItem, ...p: P): R;
    visitModFileItem?(item: Item, kind: ModFileItem, ...p: P): R;
    visitEnumItem?(item: Item, kind: EnumItem, ...p: P): R;
    visitStructItem?(item: Item, kind: StructItem, ...p: P): R;
    visitFnItem?(item: Item, kind: FnItem, ...p: P): R;
    visitUseItem?(item: Item, kind: UseItem, ...p: P): R;
    visitTypeAliasItem?(item: Item, kind: TypeAliasItem, ...p: P): R;

    visitExpr?(expr: Expr, ...p: P): R;
    visitErrorExpr?(expr: Expr, ...p: P): R;
    visitPathExpr?(expr: Expr, kind: Path, ...p: P): R;
    visitNullExpr?(expr: Expr, ...p: P): R;
    visitIntExpr?(expr: Expr, kind: IntExpr, ...p: P): R;
    visitBoolExpr?(expr: Expr, kind: BoolExpr, ...p: P): R;
    visitStringExpr?(expr: Expr, kind: StringExpr, ...p: P): R;
    visitGroupExpr?(expr: Expr, kind: GroupExpr, ...p: P): R;
    visitArrayExpr?(expr: Expr, kind: ArrayExpr, ...p: P): R;
    visitRepeatExpr?(expr: Expr, kind: RepeatExpr, ...p: P): R;
    visitStructExpr?(expr: Expr, kind: StructExpr, ...p: P): R;
    visitRefExpr?(expr: Expr, kind: RefExpr, ...p: P): R;
    visitDerefExpr?(expr: Expr, kind: DerefExpr, ...p: P): R;
    visitElemExpr?(expr: Expr, kind: ElemExpr, ...p: P): R;
    visitFieldExpr?(expr: Expr, kind: FieldExpr, ...p: P): R;
    visitIndexExpr?(expr: Expr, kind: IndexExpr, ...p: P): R;
    visitCallExpr?(expr: Expr, kind: CallExpr, ...p: P): R;
    visitUnaryExpr?(expr: Expr, kind: UnaryExpr, ...p: P): R;
    visitBinaryExpr?(expr: Expr, kind: BinaryExpr, ...p: P): R;
    visitIfExpr?(expr: Expr, kind: IfExpr, ...p: P): R;
    visitLoopExpr?(expr: Expr, kind: LoopExpr, ...p: P): R;
    visitWhileExpr?(expr: Expr, kind: WhileExpr, ...p: P): R;
    visitForExpr?(expr: Expr, kind: ForExpr, ...p: P): R;
    visitCForExpr?(expr: Expr, kind: CForExpr, ...p: P): R;

    visitPat?(pat: Pat, ...p: P): R;
    visitErrorPat?(pat: Pat, ...p: P): R;
    visitBindPat?(pat: Pat, kind: BindPat, ...p: P): R;

    visitTy?(ty: Ty, ...p: P): R;
    visitErrorTy?(ty: Ty, ...p: P): R;
    visitPathTy?(ty: Ty, kind: Path, ...p: P): R;
    visitRefTy?(ty: Ty, kind: RefTy, ...p: P): R;
    visitPtrTy?(ty: Ty, kind: PtrTy, ...p: P): R;
    visitSliceTy?(ty: Ty, kind: SliceTy, ...p: P): R;
    visitArrayTy?(ty: Ty, kind: ArrayTy, ...p: P): R;
    visitTupleTy?(ty: Ty, kind: TupleTy, ...p: P): R;
    visitAnonStructTy?(ty: Ty, kind: AnonStructTy, ...p: P): R;

    visitPath?(path: Path, ...p: P): R;
    visitIdent?(ident: Ident, ...p: P): R;
}

export function visitFile<
    P extends PM = [],
>(
    v: Visitor<P>,
    file: File,
    ...p: P
) {
    if (v.visitFile?.(file, ...p) === "stop") return;
    visitStmts(v, file.stmts, ...p);
}

export function visitStmts<
    P extends PM = [],
>(
    v: Visitor<P>,
    stmts: Stmt[],
    ...p: P
) {
    for (const stmt of stmts) {
        visitStmt(v, stmt, ...p);
    }
}

export function visitStmt<
    P extends PM = [],
>(
    v: Visitor<P>,
    stmt: Stmt,
    ...p: P
) {
    const kind = stmt.kind;
    switch (kind.tag) {
        case "error":
            if (v.visitErrorStmt?.(stmt, ...p) === "stop") return;
            return;
        case "item":
            if (v.visitItemStmt?.(stmt, kind, ...p) === "stop") return;
            return;
        case "let":
            if (v.visitLetStmt?.(stmt, kind, ...p) === "stop") return;
            return;
        case "return":
            if (v.visitReturnStmt?.(stmt, kind, ...p) === "stop") return;
            return;
        case "break":
            if (v.visitBreakStmt?.(stmt, kind, ...p) === "stop") return;
            return;
        case "continue":
            if (v.visitContinueStmt?.(stmt, ...p) === "stop") return;
            return;
        case "assign":
            if (v.visitAssignStmt?.(stmt, kind, ...p) === "stop") return;
            return;
        case "expr":
            if (v.visitExprStmt?.(stmt, kind, ...p) === "stop") return;
            return;
    }
    exhausted(kind);
}

export function visitItem<
    P extends PM = [],
>(
    v: Visitor<P>,
    item: Item,
    ...p: P
) {
    const kind = item.kind;
    switch (kind.tag) {
        case "error":
            if (v.visitErrorItem?.(item, ...p) === "stop") return;
            return;
        case "mod_block":
            if (v.visitModBlockItem?.(item, kind, ...p) === "stop") return;
            return;
        case "mod_file":
            if (v.visitModFileItem?.(item, kind, ...p) === "stop") return;
            return;
        case "enum":
            if (v.visitEnumItem?.(item, kind, ...p) === "stop") return;
            return;
        case "struct":
            if (v.visitStructItem?.(item, kind, ...p) === "stop") return;
            return;
        case "fn":
            if (v.visitFnItem?.(item, kind, ...p) === "stop") return;
            return;
        case "use":
            if (v.visitUseItem?.(item, kind, ...p) === "stop") return;
            return;
        case "type_alias":
            if (v.visitTypeAliasItem?.(item, kind, ...p) === "stop") return;
            return;
    }
    exhausted(kind);
}

export function visitExpr<
    P extends PM = [],
>(
    v: Visitor<P>,
    expr: Expr,
    ...p: P
) {
    const kind = expr.kind;
    switch (kind.tag) {
        case "error":
            if (v.visitErrorExpr?.(expr, ...p) === "stop") return;
            return;
        case "ident":
            if (v.visitIdentExpr?.(expr, kind, ...p) === "stop") return;
            return;
    }
    exhausted(kind);
}

export function visitPat<
    P extends PM = [],
>(
    v: Visitor<P>,
    pat: Pat,
    ...p: P
) {
    const kind = pat.kind;
    switch (kind.tag) {
        case "error":
            if (v.visitErrorPat?.(pat, ...p) === "stop") return;
            return;
        case "bind":
            if (v.visitBindPat?.(pat, kind, ...p) === "stop") return;
            return;
    }
    exhausted(kind);
}

export function visitTy<
    P extends PM = [],
>(
    v: Visitor<P>,
    ty: Ty,
    ...p: P
) {
    const kind = ty.kind;
    switch (kind.tag) {
        case "error":
            if (v.visitErrorTy?.(ty, ...p) === "stop") return;
            return;
        case "ident":
            if (v.visitIdentTy?.(ty, kind, ...p) === "stop") return;
            return;
    }
    exhausted(kind);
}

export function visitIdent<
    P extends PM = [],
>(
    v: Visitor<P>,
    ident: Ident,
    ...p: P
) {
    v.visitIdent?.(ident, ...p);
}