fix more stuff

Author: Roger-luo

src/bloqade/qasm2/dialects/inline.py

@@ -36,10 +36,23 @@ def lower(
                 "InlineQASM takes a string literal or global string"
             )
 
+        from kirin.dialects import ilist
+
+        from bloqade.qasm2.groups import main
+        from bloqade.qasm2.dialects import glob, noise, parallel
+
         raw = textwrap.dedent(value)
-        qasm_lowering = QASM2(state.parent.dialects)
-        code = qasm_lowering.run(loads(raw))
-        code.print()
+        qasm_lowering = QASM2(main.union([ilist, glob, noise, parallel]))
+        region = qasm_lowering.run(loads(raw))
+        for qasm_stmt in region.blocks[0].stmts:
+            qasm_stmt.detach()
+            state.current_frame.push(qasm_stmt)
+
+        for block in region.blocks:
+            for qasm_stmt in block.stmts:
+                qasm_stmt.detach()
+                state.current_frame.push(qasm_stmt)
+            state.current_frame.jump_next_block()
 
 
 # NOTE: this is a dummy statement that won't appear in IR.

src/bloqade/qasm2/parse/lowering.py

@@ -15,30 +15,32 @@ class QASM2(lowering.LoweringABC[ast.Node]):
     max_lines: int = field(default=3, kw_only=True)
     hint_indent: int = field(default=2, kw_only=True)
     hint_show_lineno: bool = field(default=True, kw_only=True)
-    stacktrace: bool = field(default=False, kw_only=True)
+    stacktrace: bool = field(default=True, kw_only=True)
 
     def run(
         self,
         stmt: ast.Node,
         *,
-        state: lowering.State | None = None,
         source: str | None = None,
         globals: dict[str, Any] | None = None,
         file: str | None = None,
         lineno_offset: int = 0,
         col_offset: int = 0,
         compactify: bool = True,
-    ) -> ir.Statement:
+    ) -> ir.Region:
         # TODO: add source info
-        state = state or lowering.State(
+        state = lowering.State(
             self,
             file=file,
             lineno_offset=lineno_offset,
             col_offset=col_offset,
         )
-        with state.frame([stmt], globals=globals) as frame:
+        with state.frame(
+            [stmt],
+            globals=globals,
+        ) as frame:
             try:
-                state.lower(stmt)
+                self.visit(state, stmt)
             except lowering.BuildError as e:
                 hint = state.error_hint(
                     e,
@@ -56,22 +58,27 @@ def run(
                     raise e
 
             region = frame.curr_region
-            if not region.blocks:
-                raise ValueError("No block generated")
-
-            code = region.blocks[0].first_stmt
-            if code is None:
-                raise ValueError("No code generated")
 
         if compactify:
             from kirin.rewrite import Walk, CFGCompactify
 
-            Walk(CFGCompactify()).rewrite(code)
-        return code
+            Walk(CFGCompactify()).rewrite(region)
+        return region
+
+    def visit(self, state: lowering.State[ast.Node], node: ast.Node) -> lowering.Result:
+        name = node.__class__.__name__
+        return getattr(self, f"visit_{name}", self.generic_visit)(state, node)
 
-    def visit(
+    def generic_visit(
         self, state: lowering.State[ast.Node], node: ast.Node
-    ) -> lowering.Result: ...
+    ) -> lowering.Result:
+        if isinstance(node, ast.Node):
+            raise lowering.BuildError(
+                f"Cannot lower {node.__class__.__name__} node: {node}"
+            )
+        raise lowering.BuildError(
+            f"Unexpected `{node.__class__.__name__}` node: {repr(node)} is not an AST node"
+        )
 
     def lower_literal(self, state: lowering.State[ast.Node], value) -> ir.SSAValue:
         if isinstance(value, int):
@@ -261,7 +268,7 @@ def visit_BinOp(self, state: lowering.State[ast.Node], node: ast.BinOp):
         else:
             stmt_type = expr.Div
 
-        state.current_frame.push(
+        return state.current_frame.push(
             stmt_type(
                 lhs=state.lower(node.lhs).expect_one(),
                 rhs=state.lower(node.rhs).expect_one(),
@@ -398,7 +405,8 @@ def visit_Number(self, state: lowering.State[ast.Node], node: ast.Number):
             stmt = expr.ConstInt(value=node.value)
         else:
             stmt = expr.ConstFloat(value=node.value)
-        return state.current_frame.push(stmt).result
+        state.current_frame.push(stmt)
+        return stmt
 
     def visit_Pi(self, state: lowering.State[ast.Node], node: ast.Pi):
         return state.current_frame.push(expr.ConstPI()).result

src/bloqade/qasm2/passes/qasm2py.py

@@ -17,11 +17,11 @@ class _QASM2Py(RewriteRule):
 
     UNARY_OPS = {
         expr.Neg: py.USub,
-        expr.Sin: math.sin,
-        expr.Cos: math.cos,
-        expr.Tan: math.tan,
-        expr.Exp: math.exp,
-        expr.Sqrt: math.sqrt,
+        expr.Sin: math.stmts.sin,
+        expr.Cos: math.stmts.cos,
+        expr.Tan: math.stmts.tan,
+        expr.Exp: math.stmts.exp,
+        expr.Sqrt: math.stmts.sqrt,
     }
 
     BINARY_OPS = {

test/qasm2/passes/test_heuristic_noise.py

@@ -12,6 +12,8 @@
 
 
 class NoiseTestModel(native.MoveNoiseModelABC):
+
+    @classmethod
     def parallel_cz_errors(cls, ctrls, qargs, rest):
         return {(0.01, 0.01, 0.01, 0.01): ctrls + qargs + rest}
 

test/qasm2/test_inline.py

@@ -64,51 +64,3 @@ def qasm2_inline_code():
         qasm2.inline(lines)
 
     qasm2_inline_code.print()
-
-
-if __name__ == "__main__":
-    # test_inline()
-
-    lines = textwrap.dedent(
-        """
-    KIRIN {qasm2.glob, qasm2.uop};
-    include "qelib1.inc";
-
-    qreg q1[2];
-    qreg q2[3];
-
-    glob.U(1.0, 2.0, 3.0) {q1, q2}
-    """
-    )
-
-    print(lines)
-
-    @qasm2.extended.add(inline)
-    def qasm2_inline_code():
-        qasm2.inline(lines)
-
-    qasm2_inline_code.print()
-
-
-lines = textwrap.dedent(
-    """
-OPENQASM 2.0;
-
-qreg q[2];
-creg c[2];
-
-h q[0];
-CX q[0], q[1];
-barrier q[0], q[1];
-CX q[0], q[1];
-rx(pi/2) q[0];
-"""
-)
-
-
-@qasm2.main.add(inline)
-def qasm2_inline_code():
-    qasm2.inline(lines)
-
-
-qasm2_inline_code.print()

test/qasm2/test_lowering.py

@@ -0,0 +1,22 @@
+import textwrap
+
+from bloqade import qasm2
+from bloqade.qasm2.parse.lowering import QASM2
+
+lines = textwrap.dedent(
+    """
+OPENQASM 2.0;
+
+qreg q[2];
+creg c[2];
+
+h q[0];
+CX q[0], q[1];
+barrier q[0], q[1];
+CX q[0], q[1];
+rx(pi/2) q[0];
+"""
+)
+ast = qasm2.parse.loads(lines)
+code = QASM2(qasm2.main).run(ast)
+code.print()