merged is_equal with is_structurally_equal. issue 514 (#515)

Addressing #514 
Merged all usage of `is_equal` with `is_structurally_equal`.

---------

Co-authored-by: kaihsin <[email protected]>

Author: zhenrongliew

src/kirin/analysis/const/lattice.py

@@ -84,11 +84,6 @@ class Value(Result):
     def is_subseteq_Value(self, other: "Value") -> bool:
         return self.data == other.data
 
-    def is_equal(self, other: Result) -> bool:
-        if isinstance(other, Value):
-            return self.data == other.data
-        return False
-
     def __hash__(self) -> int:
         # NOTE: we use id here because the data
         # may not be hashable. This is fine because
@@ -100,9 +95,7 @@ def is_structurally_equal(
     ) -> bool:
         if not isinstance(other, Value):
             return False
-        if isinstance(self.data, ir.Attribute) and isinstance(other.data, ir.Attribute):
-            return self.data.is_structurally_equal(other.data, context=context)
-        return self.data.is_structurally_equal(other.data, context=context)
+        return self.data == other.data
 
 
 @dataclass
@@ -159,13 +152,6 @@ def meet(self, other: Result) -> Result:
             )
         return self.bottom()
 
-    def is_equal(self, other: Result) -> bool:
-        if isinstance(other, PartialTuple):
-            return all(x.is_equal(y) for x, y in zip(self.data, other.data))
-        elif isinstance(other, Value) and isinstance(other.data, tuple):
-            return all(x.is_equal(Value(y)) for x, y in zip(self.data, other.data))
-        return False
-
     def is_subseteq_PartialTuple(self, other: "PartialTuple") -> bool:
         return all(x.is_subseteq(y) for x, y in zip(self.data, other.data))
 
@@ -180,14 +166,17 @@ def __hash__(self) -> int:
     def is_structurally_equal(
         self, other: ir.Attribute, context: dict | None = None
     ) -> bool:
-        if not isinstance(other, PartialTuple):
-            return False
-        if len(self.data) != len(other.data):
-            return False
-        return all(
-            x.is_structurally_equal(y, context=context)
-            for x, y in zip(self.data, other.data)
-        )
+        if isinstance(other, PartialTuple):
+            return all(
+                x.is_structurally_equal(y, context=context)
+                for x, y in zip(self.data, other.data)
+            )
+        elif isinstance(other, Value) and isinstance(other.data, tuple):
+            return all(
+                x.is_structurally_equal(y, context=context)
+                for x, y in zip(self.data, other.data)
+            )
+        return False
 
 
 @final

src/kirin/dialects/ilist/runtime.py

@@ -101,7 +101,7 @@ def is_structurally_equal(
         return (
             isinstance(other, IList)
             and self.data == other.data
-            and self.elem.is_equal(other.elem)
+            and self.elem.is_structurally_equal(other.elem, context=context)
         )
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":

src/kirin/ir/attrs/abc.py

@@ -55,7 +55,6 @@ def __hash__(self) -> int: ...
     @abstractmethod
     def __eq__(self, value: object) -> bool: ...
 
-    @abstractmethod
     def is_structurally_equal(self, other: Self, context: dict | None = None) -> bool:
         return self == other
 

src/kirin/ir/attrs/types.py

@@ -84,7 +84,12 @@ def __or__(self, other: "TypeAttribute"):
         return self.join(other)
 
     def __eq__(self, value: object) -> bool:
-        return isinstance(value, TypeAttribute) and self.is_equal(value)
+        return isinstance(value, TypeAttribute) and self.is_structurally_equal(value)
+
+    @abstractmethod
+    def is_structurally_equal(
+        self, other: "Attribute", context: dict | None = None
+    ) -> bool: ...
 
     @abstractmethod
     def __hash__(self) -> int: ...
@@ -286,13 +291,6 @@ def __eq__(self, other: object) -> bool:
             return False
         return self.data == other.data and self.type == other.type
 
-    def is_equal(self, other: TypeAttribute) -> bool:
-        return (
-            isinstance(other, Literal)
-            and self.type.is_equal(other.type)
-            and self.data == other.data
-        )
-
     def is_subseteq_TypeVar(self, other: "TypeVar") -> bool:
         return self.is_subseteq(other.bound)
 
@@ -317,7 +315,7 @@ def is_structurally_equal(
         return (
             isinstance(other, Literal)
             and self.data == other.data
-            and self.type.is_equal(other.type)
+            and self.type.is_structurally_equal(other.type, context=context)
         )
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
@@ -355,9 +353,6 @@ def __init__(
                 types = types.union({typ})
         self.types = types
 
-    def is_equal(self, other: TypeAttribute) -> bool:
-        return isinstance(other, Union) and self.types == other.types
-
     def is_subseteq_fallback(self, other: TypeAttribute) -> bool:
         return all(t.is_subseteq(other) for t in self.types)
 
@@ -416,13 +411,6 @@ def __init__(self, name: str, bound: TypeAttribute | None = None):
         self.varname = name
         self.bound = bound or AnyType()
 
-    def is_equal(self, other: TypeAttribute) -> bool:
-        return (
-            isinstance(other, TypeVar)
-            and self.varname == other.varname
-            and self.bound.is_equal(other.bound)
-        )
-
     def is_subseteq_TypeVar(self, other: "TypeVar") -> bool:
         return self.bound.is_subseteq(other.bound)
 
@@ -447,7 +435,7 @@ def is_structurally_equal(
         return (
             isinstance(other, TypeVar)
             and self.varname == other.varname
-            and self.bound.is_equal(other.bound)
+            and self.bound.is_structurally_equal(other.bound, context=context)
         )
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
@@ -482,7 +470,7 @@ def print_impl(self, printer: Printer) -> None:
     def is_structurally_equal(
         self, other: Attribute, context: dict | None = None
     ) -> bool:
-        return isinstance(other, Vararg) and self.typ.is_equal(other.typ)
+        return isinstance(other, Vararg) and self.typ.is_structurally_equal(other.typ)
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
         return serializer.serialize_vararg(self)
@@ -626,12 +614,17 @@ def is_structurally_equal(
             return False
         if len(self.vars) != len(other.vars):
             return False
-        if any(not v.is_equal(o) for v, o in zip(self.vars, other.vars)):
+        if any(
+            not v.is_structurally_equal(o, context=context)
+            for v, o in zip(self.vars, other.vars)
+        ):
             return False
         if self.vararg is None and other.vararg is None:
             return True
         if self.vararg is not None and other.vararg is not None:
-            return self.vararg.typ.is_equal(other.vararg.typ)
+            return self.vararg.typ.is_structurally_equal(
+                other.vararg.typ, context=context
+            )
         return False
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":

src/kirin/ir/nodes/base.py

@@ -58,25 +58,6 @@ def get_root(self) -> IRNode:
             return self
         return parent.get_root()
 
-    def is_equal(self, other: IRNode, context: dict = {}) -> bool:
-        """Check if the current node is equal to the other node.
-
-        Args:
-            other: The other node to compare.
-            context: The context to store the visited nodes. Defaults to {}.
-
-        Returns:
-            True if the nodes are equal, False otherwise.
-
-        !!! note
-            This method is not the same as the `==` operator. It checks for
-            structural equality rather than identity. To change the behavior
-            of structural equality, override the `is_structurally_equal` method.
-        """
-        if not isinstance(other, type(self)):
-            return False
-        return self.is_structurally_equal(other, context)
-
     def attach(self, parent: ParentType) -> None:
         """Attach the current node to the parent node."""
         assert isinstance(parent, IRNode), f"Expected IRNode, got {type(parent)}"
@@ -116,7 +97,7 @@ def is_structurally_equal(
 
         !!! note
             This method is for tweaking the behavior of structural equality.
-            To check if two nodes are structurally equal, use the `is_equal` method.
+            To check if two nodes are structurally equal, use the `is_structurally_equal` method.
 
         Args:
             other: The other node to compare.

src/kirin/lattice/abc.py

@@ -49,7 +49,9 @@ def is_subseteq(self, other: LatticeType) -> bool:
         """Subseteq operation."""
         ...
 
-    def is_equal(self, other: LatticeType) -> bool:
+    def is_structurally_equal(
+        self, other: LatticeType, context: dict | None = None
+    ) -> bool:
         """Check if two lattices are equal."""
         if self is other:
             return True
@@ -61,7 +63,7 @@ def is_subset(self, other: LatticeType) -> bool:
 
     def __eq__(self, value: object) -> bool:
         raise NotImplementedError(
-            "Equality is not implemented for lattices, use is_equal instead"
+            "Equality is not implemented for lattices, use is_structurally_equal instead"
         )
 
     def __hash__(self) -> int:

src/kirin/rewrite/wrap_const.py

@@ -27,7 +27,7 @@ def wrap(self, value: ir.SSAValue) -> bool:
         const_hint = value.hints.get("const")
         if const_hint and isinstance(const_hint, const.Result):
             const_result = result.meet(const_hint)
-            if const_result.is_equal(const_hint):
+            if const_result.is_structurally_equal(const_hint):
                 return False
         else:
             const_result = result

test/analysis/dataflow/constprop/test_constprop.py

@@ -72,40 +72,40 @@ def test_join(self):
             == const.Unknown()
         )
 
-    def test_is_equal(self):
-        assert const.Unknown().is_equal(const.Unknown())
-        assert not const.Unknown().is_equal(const.Bottom())
-        assert not const.Unknown().is_equal(const.Value(1))
-        assert const.Bottom().is_equal(const.Bottom())
-        assert not const.Bottom().is_equal(const.Value(1))
-        assert const.Value(1).is_equal(const.Value(1))
-        assert not const.Value(1).is_equal(const.Value(2))
-        assert const.PartialTuple((const.Value(1), const.Bottom())).is_equal(
-            const.PartialTuple((const.Value(1), const.Bottom()))
-        )
-        assert not const.PartialTuple((const.Value(1), const.Bottom())).is_equal(
-            const.PartialTuple((const.Value(1), const.Value(2)))
-        )
+    def test_is_structurally_equal(self):
+        assert const.Unknown().is_structurally_equal(const.Unknown())
+        assert not const.Unknown().is_structurally_equal(const.Bottom())
+        assert not const.Unknown().is_structurally_equal(const.Value(1))
+        assert const.Bottom().is_structurally_equal(const.Bottom())
+        assert not const.Bottom().is_structurally_equal(const.Value(1))
+        assert const.Value(1).is_structurally_equal(const.Value(1))
+        assert not const.Value(1).is_structurally_equal(const.Value(2))
+        assert const.PartialTuple(
+            (const.Value(1), const.Bottom())
+        ).is_structurally_equal(const.PartialTuple((const.Value(1), const.Bottom())))
+        assert not const.PartialTuple(
+            (const.Value(1), const.Bottom())
+        ).is_structurally_equal(const.PartialTuple((const.Value(1), const.Value(2))))
 
     def test_partial_tuple(self):
         pt1 = const.PartialTuple((const.Value(1), const.Bottom()))
         pt2 = const.PartialTuple((const.Value(1), const.Bottom()))
-        assert pt1.is_equal(pt2)
+        assert pt1.is_structurally_equal(pt2)
         assert pt1.is_subseteq(pt2)
         assert pt1.join(pt2) == pt1
         assert pt1.meet(pt2) == pt1
         pt2 = const.PartialTuple((const.Value(1), const.Value(2)))
-        assert not pt1.is_equal(pt2)
+        assert not pt1.is_structurally_equal(pt2)
         assert pt1.is_subseteq(pt2)
         assert pt1.join(pt2) == const.PartialTuple((const.Value(1), const.Value(2)))
         assert pt1.meet(pt2) == const.PartialTuple((const.Value(1), const.Bottom()))
         pt2 = const.PartialTuple((const.Value(1), const.Bottom()))
-        assert pt1.is_equal(pt2)
+        assert pt1.is_structurally_equal(pt2)
         assert pt1.is_subseteq(pt2)
         assert pt1.join(pt2) == pt1
         assert pt1.meet(pt2) == pt1
         pt2 = const.PartialTuple((const.Value(1), const.Unknown()))
-        assert not pt1.is_equal(pt2)
+        assert not pt1.is_structurally_equal(pt2)
         assert pt1.is_subseteq(pt2)
         assert pt1.join(pt2) == pt2
         assert pt1.meet(pt2) == pt1

test/analysis/dataflow/typeinfer/test_selfref_closure.py

@@ -22,4 +22,6 @@ def self_ref_source(i_layer):
     infer = TypeInference(structural_no_opt)
     frame, ret = infer.run(should_work, types.Int)
     should_work.print(analysis=frame.entries)
-    assert ret.is_equal(types.MethodType[types.Tuple[types.Any], types.NoneType])
+    assert ret.is_structurally_equal(
+        types.MethodType[types.Tuple[types.Any], types.NoneType]
+    )

test/dialects/py/test_assign.py

@@ -18,7 +18,7 @@ def test_ann_assign():
 
     typeinfer = TypeInference(basic_no_opt)
     _, ret = typeinfer.run(main, types.Int)
-    assert ret.is_equal(types.Int)
+    assert ret.is_structurally_equal(types.Int)
     _, ret = typeinfer.run(main, types.Float)
     assert ret is ret.bottom()
 
@@ -41,9 +41,13 @@ def list_assign():
 
     stmt = list_assign.callable_region.blocks[0].stmts.at(3)
     assert isinstance(stmt, ilist.New)
-    assert stmt.elem_type.is_equal(types.Float)
-    assert stmt.result.type.is_equal(ilist.IListType[types.Float, types.Literal(3)])
+    assert stmt.elem_type.is_structurally_equal(types.Float)
+    assert stmt.result.type.is_structurally_equal(
+        ilist.IListType[types.Float, types.Literal(3)]
+    )
 
     stmt = list_assign.callable_region.blocks[0].stmts.at(4)
     assert isinstance(stmt, py.assign.TypeAssert)
-    assert stmt.expected.is_equal(ilist.IListType[types.Float, types.Literal(3)])
+    assert stmt.expected.is_structurally_equal(
+        ilist.IListType[types.Float, types.Literal(3)]
+    )