Rafaelha/fix has_done_something and fixpoint logic (#545)

This PR fixes several issues related to fixpoint rewrites:

1. A subtle bug in `Pass.fixpoint` lead to rewrites being applied for
`max_iter` iterations, even if they had already converged.
2. Several compiler passes were incorrectly returning
`has_done_something=True`, even if they had not done anything, leading
to maxed out fixpoint loops.
3. The CSE rewrite would prematurely exit, leading to more fixpoint
iterations.

I checked that all tests in the kirin test suite lead to fixpoint
rewrites that converge before reaching `max_iter`. It's still possible
that there are more rewrite passes that need to be fixed. We should
consider raising an error or at least a warning if a fixpoint pass does
not converge, as this will immediately point us to any such issues in
the future.

**The default `max_iter` is set to 32. With this fix, many passes now
iterate only once or twice instead of 32 times. So in many cases there
is a 32x speedup. Some passes also contain a fixpoint within a fixpoint.
They can now become 1000x faster.**

I noticed these issues when running the following script
```python
    @qasm2.extended  # O(n) scaling
    def main_fun():
        qreg = qasm2.qreg(1)
        for _ in range(n):
            qasm2.h(qreg[0])

    QASM2().emit(main_fun)  # ~O(n^1.5)
```

This script runs really slow for large `n`. But even more important,
recording the duration of compilation and QASM2 emission, I found
non-linear scaling ~ O(n^1.5). Any compiler pass must be linear in the
program size (or at worst n log n).

<img width="331" height="250" alt="image"
src="https://github.com/user-attachments/assets/c914db82-e2c6-4821-8a0e-b00ab19b432c"
/>

With the fixes in this PR, the execution time of this script is
significantly faster and the computational complexity is back to the
expected O(n):
<img width="331" height="245" alt="image"
src="https://github.com/user-attachments/assets/35480c95-29b5-4117-b796-c4cc891d1cb0"
/>

These issues also affect the runtime of @cduck's flair-to-squin pipeline
- but I think there are additional slowdowns that I'm still looking
into.

Author: rafaelha

src/kirin/dialects/ilist/rewrite/const.py

@@ -27,11 +27,15 @@ def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
             typ = result.type
             data = hint.data
             if isinstance(typ, types.PyClass) and typ.is_subseteq(types.PyClass(IList)):
-                has_done_something = self._rewrite_IList_type(result, data)
+                has_done_something = has_done_something or self._rewrite_IList_type(
+                    result, data
+                )
             elif isinstance(typ, types.Generic) and typ.body.is_subseteq(
                 types.PyClass(IList)
             ):
-                has_done_something = self._rewrite_IList_type(result, data)
+                has_done_something = has_done_something or self._rewrite_IList_type(
+                    result, data
+                )
         return RewriteResult(has_done_something=has_done_something)
 
     def rewrite_Constant(self, node: Constant) -> RewriteResult:
@@ -53,6 +57,13 @@ def _rewrite_IList_type(self, result: ir.SSAValue, data):
         for elem in data.data[1:]:
             elem_type = elem_type.join(types.PyClass(type(elem)))
 
-        result.type = IListType[elem_type, types.Literal(len(data.data))]
-        result.hints["const"] = const.Value(data)
+        new_type = IListType[elem_type, types.Literal(len(data.data))]
+        new_hint = const.Value(data)
+
+        # Check if type and hint are already correct
+        if result.type == new_type and result.hints.get("const") == new_hint:
+            return False
+
+        result.type = new_type
+        result.hints["const"] = new_hint
         return True

src/kirin/dialects/ilist/rewrite/hint_len.py

@@ -32,6 +32,11 @@ def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
         if (coll_len := self._get_collection_len(node.value)) is None:
             return RewriteResult()
 
-        node.result.hints["const"] = const.Value(coll_len)
+        existing_hint = node.result.hints.get("const")
+        new_hint = const.Value(coll_len)
 
+        if existing_hint is not None and new_hint.is_structurally_equal(existing_hint):
+            return RewriteResult()
+
+        node.result.hints["const"] = new_hint
         return RewriteResult(has_done_something=True)

src/kirin/dialects/ilist/rewrite/list.py

@@ -13,7 +13,7 @@ class List2IList(RewriteRule):
     def rewrite_Block(self, node: ir.Block) -> RewriteResult:
         has_done_something = False
         for arg in node.args:
-            has_done_something = self._rewrite_SSAValue_type(arg)
+            has_done_something = has_done_something or self._rewrite_SSAValue_type(arg)
         return RewriteResult(has_done_something=has_done_something)
 
     def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
@@ -25,7 +25,9 @@ def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
             )
 
         for result in node.results:
-            has_done_something = self._rewrite_SSAValue_type(result)
+            has_done_something = has_done_something or self._rewrite_SSAValue_type(
+                result
+            )
 
         return RewriteResult(has_done_something=has_done_something)
 

src/kirin/passes/abc.py

@@ -36,7 +36,7 @@ def fixpoint(self, mt: Method, max_iter: int = 32) -> RewriteResult:
         for _ in range(max_iter):
             result_ = self.unsafe_run(mt)
             result = result_.join(result)
-            if not result.has_done_something:
+            if not result_.has_done_something:
                 break
         mt.verify()
         return result

src/kirin/rewrite/apply_type.py

@@ -13,17 +13,21 @@ def rewrite_Block(self, node: ir.Block) -> RewriteResult:
         has_done_something = False
         for arg in node.args:
             if arg in self.results:
-                arg.type = self.results[arg]
-                has_done_something = True
+                arg_type = self.results[arg]
+                if arg.type != arg_type:
+                    arg.type = arg_type
+                    has_done_something = True
 
         return RewriteResult(has_done_something=has_done_something)
 
     def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
         has_done_something = False
         for result in node._results:
             if result in self.results:
-                result.type = self.results[result]
-                has_done_something = True
+                arg_type = self.results[result]
+                if result.type != arg_type:
+                    result.type = arg_type
+                    has_done_something = True
 
         if (trait := node.get_trait(ir.HasSignature)) is not None and (
             callable_trait := node.get_trait(ir.CallableStmtInterface)

src/kirin/rewrite/cse.py

@@ -61,6 +61,7 @@ class CommonSubexpressionElimination(RewriteRule):
 
     def rewrite_Block(self, node: ir.Block) -> RewriteResult:
         seen: dict[Info, ir.Statement] = {}
+        has_done_something = False
 
         for stmt in node.stmts:
             if not stmt.has_trait(ir.Pure):
@@ -81,10 +82,10 @@ def rewrite_Block(self, node: ir.Block) -> RewriteResult:
                 for result, old_result in zip(stmt._results, old_stmt.results):
                     result.replace_by(old_result)
                 stmt.delete()
-                return RewriteResult(has_done_something=True)
+                has_done_something = True
             else:
                 seen[info] = stmt
-        return RewriteResult()
+        return RewriteResult(has_done_something=has_done_something)
 
     def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
         if not node.regions:

src/kirin/rewrite/fold.py

@@ -29,6 +29,8 @@ def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
         has_done_something = False
         for old_result in node.results:
             if (value := self.get_const(old_result)) is not None:
+                if not old_result.uses:
+                    continue
                 stmt = Constant(value.data)
                 stmt.insert_before(node)
                 old_result.replace_by(stmt.result)

src/kirin/rewrite/walk.py

@@ -31,6 +31,8 @@ def rewrite(self, node: IRNode) -> RewriteResult:
         # NOTE: because the rewrite pass may mutate the node
         # thus we need to save the list of nodes to be processed
         # first before we start processing them
+        assert self.worklist.is_empty()
+
         self.populate_worklist(node)
         has_done_something = False
         subnode = self.worklist.pop()

src/kirin/rewrite/wrap_const.py

@@ -48,8 +48,10 @@ def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
                 has_done_something = True
 
         if (
-            trait := node.get_trait(ir.MaybePure)
-        ) and node in self.frame.should_be_pure:
+            (trait := node.get_trait(ir.MaybePure))
+            and node in self.frame.should_be_pure
+            and not trait.is_pure(node)
+        ):
             trait.set_pure(node)
             has_done_something = True
         return RewriteResult(has_done_something=has_done_something)