remove old mir stringification

src/stringify.ts

@@ -42,150 +42,8 @@ export function tyPretty(ty: ty.Ty): string {
 }
 
 export function mirFnPretty(fn: mir.Fn): string {
-    // return mirFnPrettyNew(fn);
-    return mirFnPrettyOld(fn);
-}
-export function mirFnPrettyNew(fn: mir.Fn): string {
     return new MirFnPrettyStringifier(fn).stringify();
 }
-export function mirFnPrettyOld(fn: mir.Fn): string {
-    class IdMap<T> {
-        private map = new Map<T, number>();
-        private counter = 0;
-
-        id(val: T): number {
-            if (!this.map.has(val)) {
-                this.map.set(val, this.counter++);
-            }
-            return this.map.get(val)!;
-        }
-    }
-
-    class PrettyCx {
-        private bbIds = new IdMap<mir.BasicBlock>();
-        private regIds = new IdMap<mir.Inst>();
-
-        bbId(bb: mir.BasicBlock): number {
-            return this.bbIds.id(bb);
-        }
-        regId(reg: mir.Inst): number {
-            return this.regIds.id(reg);
-        }
-    }
-
-    function mirBasicBlockPretty(bb: mir.BasicBlock, cx: PrettyCx): string {
-        const consts = ["Void", "Int", "Bool", "Array"];
-
-        return `bb${cx.bbId(bb)}:\n${
-            bb.insts
-                .filter((inst) => !consts.includes(inst.kind.tag))
-                .map((inst) => mirInstPretty(inst, cx))
-                .map((line) => `    ${line}`)
-                .join("\n")
-        }`;
-    }
-
-    function mirInstPretty(inst: mir.Inst, cx: PrettyCx): string {
-        const valueless = ["Store", "Jump", "Branch", "Return", "DebugPrint"];
-        const valueType = `%${cx.regId(inst)} (${inst.ty.pretty()}) = `;
-        return `${
-            !valueless.includes(inst.kind.tag) ? valueType : ""
-        }${inst.kind.tag} ${mirInstArgsPretty(inst, cx)}`;
-    }
-
-    function mirInstArgsPretty(inst: mir.Inst, cx: PrettyCx): string {
-        const consts = ["Void", "Int", "Bool", "Array"];
-
-        const r = (v: mir.Inst) =>
-            consts.includes(v.kind.tag)
-                ? mirInstArgsPretty(v, cx)
-                : `%${cx.regId(v)}`;
-
-        const k = inst.kind;
-        switch (k.tag) {
-            case "Error":
-                return "";
-            case "Void":
-                return "";
-            case "Int":
-                return `${k.value}${k.intTy}`;
-            case "Bool":
-                return `${k.value}`;
-            case "Str":
-                return `${JSON.stringify(k.value)}`;
-            case "Array":
-                return `[${k.values.map(r).join(", ")}]`;
-            case "Fn":
-                return `${k.fn.stmt.kind.ident}`;
-            case "Param":
-                return `${k.idx}`;
-            case "GetElemPtr":
-                return `&[ptr ${r(k.base)}][${r(k.offset)}]`;
-            case "Slice":
-                return `&[ptr ${r(k.value)}][${k.begin ? r(k.begin) : ""}..${
-                    k.end ? r(k.end) : ""
-                }]`;
-            case "Call":
-                return `${r(k.callee)} (${k.args.map(r).join(", ")})`;
-            case "Alloca":
-                return "";
-            case "Load":
-                return `[ptr ${r(k.source)}]`;
-            case "Store":
-                return `[ptr ${r(k.target)}] = ${r(k.source)}`;
-            case "Jump":
-                return `bb${cx.bbId(k.target)}`;
-            case "Branch":
-                return `if ${r(k.cond)}: bb${cx.bbId(k.truthy)}, else: bb${
-                    cx.bbId(k.falsy)
-                }`;
-            case "Return":
-                return `${r(k.source)}`;
-            case "Not":
-            case "Negate":
-                return `${r(k.source)}`;
-            case "Eq":
-            case "Ne":
-            case "Lt":
-            case "Gt":
-            case "Lte":
-            case "Gte":
-            case "BitOr":
-            case "BitXor":
-            case "BitAnd":
-            case "Shl":
-            case "Shr":
-            case "Add":
-            case "Sub":
-            case "Mul":
-            case "Div":
-            case "Rem":
-                return `${r(k.left)} ${r(k.right)}`;
-            case "Len":
-                return `${r(k.source)}`;
-            case "DebugPrint":
-                return `${k.args.map(r).join(", ")}`;
-        }
-        return "<unhandled>";
-    }
-
-    const fnTy = fn.ty.is("FnStmt") && fn.ty.kind.ty.is("Fn")
-        ? fn.ty.kind.ty
-        : null;
-    if (!fnTy) {
-        throw new Error();
-    }
-    const cx = new PrettyCx();
-    return `fn ${fn.stmt.kind.ident}(${
-        fnTy.kind.params
-            .map((ty, idx) => `${idx}: ${ty.pretty()}`)
-            .join(", ")
-    }) -> ${fnTy.kind.retTy.pretty()}\n{\n${
-        fn.bbs
-            .map((bb) => mirBasicBlockPretty(bb, cx))
-            .join("\n")
-    }\n}`;
-}
 
 class MirFnPrettyStringifier {
     private bbIds = new Map<mir.BasicBlock, number>();