backports 511 and 518 (#519)

Author: weinbe58

src/kirin/dialects/py/constant.py

@@ -32,8 +32,13 @@ class Constant(ir.Statement, Generic[T]):
 
     # NOTE: we allow py.Constant take data.PyAttr too
     def __init__(self, value: T | ir.Data[T]) -> None:
-        if not isinstance(value, ir.Data):
+        if isinstance(value, ir.Method):
+            value = ir.PyAttr(
+                value, pytype=types.MethodType[list(value.arg_types), value.return_type]
+            )
+        elif not isinstance(value, ir.Data):
             value = ir.PyAttr(value)
+
         super().__init__(
             attributes={"value": value},
             result_types=(value.type,),

src/kirin/passes/aggressive/unroll.py

@@ -30,6 +30,6 @@ def unsafe_run(self, mt: Method):
         result = RewriteResult()
         result = Walk(PickIfElse()).rewrite(mt.code).join(result)
         result = Walk(ForLoop()).rewrite(mt.code).join(result)
-        result = self.typeinfer(mt).join(result)
-        result = self.fold(mt).join(result)
+        result = self.fold.unsafe_run(mt).join(result)
+        self.typeinfer.unsafe_run(mt)
         return result

test/analysis/dataflow/typeinfer/test_always_rewrite.py

@@ -0,0 +1,18 @@
+from kirin.passes import TypeInfer
+from kirin.prelude import basic_no_opt
+
+
+def test_always_rewrites():
+    @basic_no_opt
+    def unstable(x: int):  # type: ignore
+        y = x + 1
+        if y > 10:
+            z = y
+        else:
+            z = y + 1.2
+        return z
+
+    result = TypeInfer(dialects=unstable.dialects, no_raise=False).fixpoint(unstable)
+    assert (
+        result.has_done_something
+    )  # this will always be true because TypeInfer always rewrites type

test/analysis/dataflow/typeinfer/test_inter_method.py

@@ -1,5 +1,6 @@
 from kirin import types
-from kirin.prelude import basic
+from kirin.prelude import basic, structural
+from kirin.dialects import ilist
 
 
 @basic
@@ -28,3 +29,16 @@ def test_inter_method_infer():
     assert foo.arg_types[0] == types.Int
     assert foo.inferred is False
     assert foo.return_type is types.Any
+
+
+def test_method_constant_type_infer():
+
+    @structural(typeinfer=True, fold=False)
+    def _new(qid: int):
+        return 1
+
+    @structural(fold=False, typeinfer=True)
+    def alloc(n_iter: int):
+        return ilist.map(_new, ilist.range(n_iter))
+
+    assert alloc.return_type.is_subseteq(ilist.IListType[types.Literal(1), types.Any])