rework cf/scf lowering + rework compactify (#200)

This PR fixes a few bugs due to loop lowering.

- the `lowering.Frame` is refactored to allow lowering transform fixes
non-terminated blocks by pointing it to the `next_block` (e.g
`lowering.cf` and `lowering.func`)
- move the lowering transform for `func` dialect into separate
`lowering.func` and `lowering.call` now one can optionally choose if the
invoke statements is supported (partially address #155)
- refactor the compactify rewrites by splitting the original rule into a
few new rules with better readbility and more correctness.

Author: Roger-luo

src/kirin/dialects/cf/emit.py

@@ -30,17 +30,20 @@ def emit_cbr(
         cond = frame.get(stmt.cond)
         interp.writeln(frame, f"if {cond}")
         frame.indent += 1
-        ori = frame.get_values(stmt.then_successor.args)
         values = frame.get_values(stmt.then_arguments)
-        for x, y in zip(ori, values):
+        block_values = tuple(interp.ssa_id[x] for x in stmt.then_successor.args)
+        frame.set_values(stmt.then_successor.args, block_values)
+        for x, y in zip(block_values, values):
             interp.writeln(frame, f"{x} = {y};")
         interp.writeln(frame, f"@goto {interp.block_id[stmt.then_successor]};")
         frame.indent -= 1
         interp.writeln(frame, "else")
         frame.indent += 1
-        ori = frame.get_values(stmt.else_successor.args)
+
         values = frame.get_values(stmt.else_arguments)
-        for x, y in zip(ori, values):
+        block_values = tuple(interp.ssa_id[x] for x in stmt.else_successor.args)
+        frame.set_values(stmt.else_successor.args, block_values)
+        for x, y in zip(block_values, values):
             interp.writeln(frame, f"{x} = {y};")
         interp.writeln(frame, f"@goto {interp.block_id[stmt.else_successor]};")
         frame.indent -= 1

src/kirin/dialects/func/__init__.py

@@ -3,7 +3,6 @@
 
 from kirin.dialects.func import (
     emit as emit,
-    lower as lower,
     interp as interp,
     constprop as constprop,
     typeinfer as typeinfer,

src/kirin/dialects/func/lower.py

@@ -4,4 +4,4 @@
 provide different lowering strategies for existing statements.
 """
 
-from . import cf as cf
+from . import cf as cf, call as call, func as func

src/kirin/dialects/lowering/__init__.py

@@ -0,0 +1,48 @@
+import ast
+
+from kirin import ir, lowering
+from kirin.dialects import func
+from kirin.exceptions import DialectLoweringError
+
+dialect = ir.Dialect("lowering.call")
+
+
+@dialect.register
+class Lowering(lowering.FromPythonAST):
+
+    def lower_Call_local(
+        self, state: lowering.LoweringState, callee: ir.SSAValue, node: ast.Call
+    ) -> lowering.Result:
+        args, keywords = self.__lower_Call_args_kwargs(state, node)
+        stmt = func.Call(callee, args, kwargs=keywords)
+        return lowering.Result(state.append_stmt(stmt))
+
+    def lower_Call_global_method(
+        self,
+        state: lowering.LoweringState,
+        method: ir.Method,
+        node: ast.Call,
+    ) -> lowering.Result:
+        args, keywords = self.__lower_Call_args_kwargs(state, node)
+        stmt = func.Invoke(args, callee=method, kwargs=keywords)
+        stmt.result.type = method.return_type or ir.types.Any
+        return lowering.Result(state.append_stmt(stmt))
+
+    def __lower_Call_args_kwargs(
+        self,
+        state: lowering.LoweringState,
+        node: ast.Call,
+    ):
+        args: list[ir.SSAValue] = []
+        for arg in node.args:
+            if isinstance(arg, ast.Starred):  # TODO: support *args
+                raise DialectLoweringError("starred arguments are not supported")
+            else:
+                args.append(state.visit(arg).expect_one())
+
+        keywords = []
+        for kw in node.keywords:
+            keywords.append(kw.arg)
+            args.append(state.visit(kw.value).expect_one())
+
+        return tuple(args), tuple(keywords)