new code generator framework (#401)

This implements the new `EmitABC` based on the new interpreter
framework. While it does its job - emitting some target format in either
IO or str or whatever else.

It does not address the usecase that lowers between two Kirin dialect
groups, I'm thinking support this use case in the lowering framework
instead of emit because technically this is about constructing the same
Kirin IR based on another Kirin IR so we can just reuse the lowering
tools for constructing the Kirin IR and provide a visitor of the IR.
Otherwise it is hard to address cases like "replacing a statement with 3
statements"

Author: Roger-luo

src/kirin/dialects/debug.py

@@ -2,7 +2,7 @@
 
 import rich
 
-from kirin import ir, decl, types, interp, lowering
+from kirin import ir, decl, emit, types, interp, lowering
 
 dialect = ir.Dialect("debug")
 
@@ -66,3 +66,12 @@ def info(self, interp: interp.Interpreter, frame: interp.Frame, stmt: Info):
         rich.print(
             "[dim]└───────────────────────────────────────────────────────────────[/dim]"
         )
+
+
+@dialect.register(key="emit.julia")
+class JuliaEmit(interp.MethodTable):
+    @interp.impl(Info)
+    def info(self, emit: emit.Julia, frame: emit.JuliaFrame, stmt: Info):
+        msg = frame.get(stmt.msg)
+        inputs = " ".join(frame.get(input) for input in stmt.inputs)
+        frame.write_line(f'@info "{msg[1:-1]}" {inputs}'.strip())

src/kirin/dialects/func/__init__.py

@@ -17,3 +17,5 @@
     FuncOpCallableInterface as FuncOpCallableInterface,
 )
 from kirin.dialects.func._dialect import dialect as dialect
+
+from . import _julia as _julia

src/kirin/dialects/func/_julia.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import IO, TypeVar
+
+from kirin import emit, interp
+
+from .stmts import Invoke, Return, Function
+from ._dialect import dialect
+
+
+@dialect.register(key="emit.julia")
+class Julia(interp.MethodTable):
+
+    IO_t = TypeVar("IO_t", bound=IO)
+
+    @interp.impl(Return)
+    def return_(
+        self, emit: emit.Julia[IO_t], frame: emit.JuliaFrame[IO_t], node: Return
+    ):
+        value = frame.get(node.value)
+        frame.write_line(f"return {value}")
+
+    @interp.impl(Invoke)
+    def invoke(
+        self, emit: emit.Julia[IO_t], frame: emit.JuliaFrame[IO_t], node: Invoke
+    ):
+        func_name = emit.callables.get(node.callee.code)
+        if func_name is None:
+            emit.callable_to_emit.append(node.callee.code)
+            func_name = emit.callables.add(node.callee.code)
+
+        _, call_expr = emit.call(
+            node.callee.code, func_name, *frame.get_values(node.args)
+        )
+        frame.write_line(f"{frame.ssa[node.result]} = {call_expr}")
+        return (frame.ssa[node.result],)
+
+    @interp.impl(Function)
+    def function(
+        self, emit_: emit.Julia[IO_t], frame: emit.JuliaFrame[IO_t], node: Function
+    ):
+        func_name = emit_.callables[node]
+        frame.set(node.body.blocks[0].args[0], func_name)
+        argnames_: list[str] = []
+        for arg in node.body.blocks[0].args[1:]:
+            frame.set(arg, name := frame.ssa[arg])
+            argnames_.append(name)
+
+        argnames = ", ".join(argnames_)
+        frame.write_line(f"function {func_name}({argnames})")
+        with frame.indent():
+            for block in node.body.blocks:
+                frame.current_block = block
+                frame.write_line(f"@label {frame.block[block]}")
+                for arg in block.args:
+                    frame.set(arg, frame.ssa[arg])
+
+                for stmt in block.stmts:
+                    frame.current_stmt = stmt
+                    stmt_results = emit_.frame_eval(frame, stmt)
+
+                    match stmt_results:
+                        case tuple():
+                            frame.set_values(stmt._results, stmt_results)
+                        case _:
+                            continue
+        frame.write_line("end\n")

src/kirin/dialects/ilist/__init__.py

@@ -6,6 +6,7 @@
 """
 
 from . import (
+    _julia as _julia,
     interp as interp,
     rewrite as rewrite,
     lowering as lowering,

src/kirin/dialects/ilist/_julia.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from kirin import emit, interp
+
+from .stmts import Range
+from ._dialect import dialect
+
+
+@dialect.register(key="emit.julia")
+class JuliaMethodTable(interp.MethodTable):
+
+    @interp.impl(Range)
+    def range(self, emit_: emit.Julia, frame: emit.JuliaFrame, node: Range):
+        start = frame.get(node.start)
+        stop = frame.get(node.stop)
+        step = frame.get(node.step)
+        frame.write_line(f"{frame.ssa[node.result]} = {start}:{step}:{stop}")
+        return (frame.ssa[node.result],)

src/kirin/dialects/py/base.py

@@ -6,7 +6,7 @@
 
 import ast
 
-from kirin import ir, lowering
+from kirin import ir, interp, lowering
 
 dialect = ir.Dialect("py.base")
 
@@ -28,3 +28,11 @@ def lower_Name(self, state: lowering.State, node: ast.Name) -> lowering.Result:
 
     def lower_Expr(self, state: lowering.State, node: ast.Expr) -> lowering.Result:
         return state.parent.visit(state, node.value)
+
+
+@dialect.register(key="emit.julia")
+class PyAttrMethod(interp.MethodTable):
+
+    @interp.impl(ir.PyAttr)
+    def py_attr(self, interp, frame: interp.Frame, node: ir.PyAttr):
+        return repr(node.data)

src/kirin/dialects/py/binop/__init__.py

@@ -13,6 +13,11 @@
 `Mod`, `Pow`, `LShift`, `RShift`, `BitOr`, `BitXor`, and `BitAnd` statements.
 """
 
-from . import interp as interp, lowering as lowering, typeinfer as typeinfer
+from . import (
+    _julia as _julia,
+    interp as interp,
+    lowering as lowering,
+    typeinfer as typeinfer,
+)
 from .stmts import *  # noqa: F403
 from ._dialect import dialect as dialect

src/kirin/dialects/py/binop/_julia.py

@@ -0,0 +1,14 @@
+from kirin import emit, interp
+
+from .stmts import Add
+from ._dialect import dialect
+
+
+@dialect.register(key="emit.julia")
+class JuliaEmit(interp.MethodTable):
+    @interp.impl(Add)
+    def add(self, emit_: emit.Julia, frame: emit.JuliaFrame, node: Add):
+        lhs = frame.get(node.lhs)
+        rhs = frame.get(node.rhs)
+        frame.write_line(f"{frame.ssa[node.result]} = ({lhs} + {rhs})")
+        return (frame.ssa[node.result],)

src/kirin/dialects/py/cmp/__init__.py

@@ -11,6 +11,6 @@
 `Gt`, `GtE`, `Is`, and `IsNot` statements.
 """
 
-from . import interp as interp, lowering as lowering
+from . import _julia as _julia, interp as interp, lowering as lowering
 from .stmts import *  # noqa: F403
 from ._dialect import dialect as dialect

src/kirin/dialects/py/cmp/_julia.py

@@ -0,0 +1,14 @@
+from kirin import emit, interp
+
+from .stmts import Eq
+from ._dialect import dialect
+
+
+@dialect.register(key="emit.julia")
+class JuliaEmit(interp.MethodTable):
+    @interp.impl(Eq)
+    def add(self, emit_: emit.Julia, frame: emit.JuliaFrame, node: Eq):
+        lhs = frame.get(node.lhs)
+        rhs = frame.get(node.rhs)
+        frame.write_line(f"{frame.ssa[node.result]} = ({lhs} == {rhs})")
+        return (frame.ssa[node.result],)