✅ test: add runtime checker (#3)

Author: SigureMo

README.md

@@ -52,4 +52,4 @@ print(ast.unparse(simplified_tree))
 
 ## TODOs
 
--  [ ] Add runtime checks in uts
+-  [ ] Automatically generate test cases

pyproject.toml

@@ -80,6 +80,9 @@ combine-as-imports = true
 [tool.ruff.lint.per-file-ignores]
 "setup.py" = ["I"]
 
+[tool.pytest.ini_options]
+python_files = ["tests/*.py", "tests/**/*.py"]
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

src/expr_simplifier/analyzer/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from expr_simplifier.analyzer.extern_symbol_analyzer import analyze_external_symbols as analyze_external_symbols

src/expr_simplifier/analyzer/extern_symbol_analyzer.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import ast
+
+from expr_simplifier.symbol_table import SymbolTable
+
+
+class ExternalSymbolAnalyzer(ast.NodeVisitor):
+    def __init__(self):
+        self.symbol_table = SymbolTable()
+        self.external_symbols: list[str] = []
+
+    def visit_Name(self, node: ast.Name) -> None:
+        if isinstance(node.ctx, ast.Store):
+            self.symbol_table.define_symbol(node.id)
+        elif isinstance(node.ctx, ast.Load):
+            if not self.symbol_table.is_symbol_defined(node.id) and node.id not in self.external_symbols:
+                self.external_symbols.append(node.id)
+
+
+def analyze_external_symbols(tree: ast.AST) -> list[str]:
+    analyzer = ExternalSymbolAnalyzer()
+    analyzer.visit(tree)
+    return analyzer.external_symbols

tests/test_transforms/test_constant_folding.py

@@ -7,6 +7,8 @@
 from expr_simplifier.transforms import apply_constant_folding
 from expr_simplifier.utils import loop_until_stable
 
+from .utils import check_expr_at_runtime
+
 
 @pytest.mark.parametrize(
     ["expr", "expected"],
@@ -27,6 +29,7 @@ def test_constant_folding(expr: str, expected: str):
     transformed_tree = apply_constant_folding(tree)
     transformed_expr = ast.unparse(transformed_tree)
     assert transformed_expr == expected
+    check_expr_at_runtime(tree, transformed_tree)
 
 
 @pytest.mark.parametrize(
@@ -41,3 +44,4 @@ def test_constant_folding_loop_until_stable(expr: str, expected: str, max_iter:
     transformed_tree = loop_until_stable(tree, [apply_constant_folding], max_iter)
     transformed_expr = ast.unparse(transformed_tree)
     assert transformed_expr == expected
+    check_expr_at_runtime(tree, transformed_tree)

tests/test_transforms/test_cse.py

@@ -6,6 +6,8 @@
 
 from expr_simplifier.transforms import apply_cse
 
+from .utils import check_expr_at_runtime
+
 
 @pytest.mark.parametrize(
     ["expr", "expected"],
@@ -36,3 +38,4 @@ def test_cse(expr: str, expected: str):
     transformed_tree = apply_cse(tree)
     transformed_expr = ast.unparse(transformed_tree)
     assert transformed_expr == expected
+    check_expr_at_runtime(tree, transformed_tree)

tests/test_transforms/test_inline_named_expr.py

@@ -9,6 +9,8 @@
     apply_inline_all_named_expr,
 )
 
+from .utils import check_expr_at_runtime
+
 
 @pytest.mark.parametrize(
     ["expr", "expected"],
@@ -25,6 +27,7 @@ def test_inline_named_expr(expr: str, expected: str):
     transformed_tree = apply_inline_all_named_expr(tree)
     transformed_expr = ast.unparse(transformed_tree)
     assert transformed_expr == expected
+    check_expr_at_runtime(tree, transformed_tree)
 
 
 @pytest.mark.parametrize(
@@ -43,3 +46,4 @@ def test_constant_propagation(expr: str, expected: str):
     transformed_tree = apply_constant_propagation(tree)
     transformed_expr = ast.unparse(transformed_tree)
     assert transformed_expr == expected
+    check_expr_at_runtime(tree, transformed_tree)

tests/test_transforms/test_logical_simplification.py

@@ -10,6 +10,8 @@
     apply_remove_same_subexpression_in_logical_op,
 )
 
+from .utils import check_expr_at_runtime
+
 
 @pytest.mark.parametrize(
     ["expr", "expected"],
@@ -35,6 +37,7 @@ def test_logical_short_circuiting(expr: str, expected: str):
     transformed_tree = apply_logical_short_circuiting(tree)
     transformed_expr = ast.unparse(transformed_tree)
     assert transformed_expr == expected
+    check_expr_at_runtime(tree, transformed_tree)
 
 
 @pytest.mark.parametrize(
@@ -60,6 +63,7 @@ def test_remove_same_subexpression_in_logical_op(expr: str, expected: str):
     transformed_tree = apply_remove_same_subexpression_in_logical_op(tree)
     transformed_expr = ast.unparse(transformed_tree)
     assert transformed_expr == expected
+    check_expr_at_runtime(tree, transformed_tree)
 
 
 @pytest.mark.parametrize(
@@ -74,3 +78,4 @@ def test_logical_simplification(expr: str, expected: str):
     transformed_tree = apply_logical_simplification(tree)
     transformed_expr = ast.unparse(transformed_tree)
     assert transformed_expr == expected
+    check_expr_at_runtime(tree, transformed_tree)

tests/test_transforms/test_remove_unused_named_expr.py

@@ -6,6 +6,8 @@
 
 from expr_simplifier.transforms import apply_remove_unused_named_expr
 
+from .utils import check_expr_at_runtime
+
 
 @pytest.mark.parametrize(
     ["expr", "expected"],
@@ -20,3 +22,4 @@ def test_inline_named_expr(expr: str, expected: str):
     transformed_tree = apply_remove_unused_named_expr(tree)
     transformed_expr = ast.unparse(transformed_tree)
     assert transformed_expr == expected
+    check_expr_at_runtime(tree, transformed_tree)

tests/test_transforms/utils.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import ast
+from typing import Any
+
+from expr_simplifier.analyzer import analyze_external_symbols
+
+
+class AnyObject:
+    """A top type that can represent any object in Python"""
+
+    def __init__(self, name: str):
+        self.name = name
+
+    def __add__(self, other: Any):
+        other = AnyObject.to_any_object(other)
+        return AnyObject(f"{self.name} + {other.name}")
+
+    def __radd__(self, other: Any):
+        other = AnyObject.to_any_object(other)
+        return AnyObject(f"{other.name} + {self.name}")
+
+    def __mul__(self, other: Any):
+        other = AnyObject.to_any_object(other)
+        return AnyObject(f"{self.name} * {other.name}")
+
+    def __rmul__(self, other: Any):
+        other = AnyObject.to_any_object(other)
+        return AnyObject(f"{other.name} * {self.name}")
+
+    def __truediv__(self, other: Any):
+        other = AnyObject.to_any_object(other)
+        return AnyObject(f"{self.name} / {other.name}")
+
+    def __rtruediv__(self, other: Any):
+        other = AnyObject.to_any_object(other)
+        return AnyObject(f"{other.name} / {self.name}")
+
+    def __floordiv__(self, other: Any):
+        other = AnyObject.to_any_object(other)
+        return AnyObject(f"{self.name} // {other.name}")
+
+    def __rfloordiv__(self, other: Any):
+        other = AnyObject.to_any_object(other)
+        return AnyObject(f"{other.name} // {self.name}")
+
+    def __getattr__(self, name: str):
+        return AnyObject(f"{self.name}.{name}")
+
+    def __getitem__(self, key: Any):
+        key = AnyObject.to_any_object(key)
+        return AnyObject(f"{self.name}[{key.name}]")
+
+    def __call__(self, *args: Any, **kwargs: Any):
+        formatted_args = ", ".join(AnyObject.to_any_object(arg).name for arg in args)
+        formatted_kwargs = ", ".join(f"{key}={AnyObject.to_any_object(value).name}" for key, value in kwargs.items())
+        return AnyObject(f"{self.name}({formatted_args}, {formatted_kwargs})")
+
+    def __bool__(self):
+        return hash(self.name) % 2 == 0
+
+    def __hash__(self):
+        return hash(self.name)
+
+    # def __eq__(self, other: object):
+    #     other = AnyObject.to_any_object(other)
+    #     return AnyObject(f"{self.name} == {other.name}")
+
+    # def __ne__(self, other: object):
+    #     other = AnyObject.to_any_object(other)
+    #     return AnyObject(f"{self.name} != {other.name}")
+
+    def __lt__(self, other: Any):
+        other = AnyObject.to_any_object(other)
+        return AnyObject(f"{self.name} < {other.name}")
+
+    def __le__(self, other: Any):
+        other = AnyObject.to_any_object(other)
+        return AnyObject(f"{self.name} <= {other.name}")
+
+    def __repr__(self):
+        return f"AnyObject({self.name})"
+
+    @staticmethod
+    def to_any_object(value: Any):
+        if isinstance(value, AnyObject):
+            return value
+        return AnyObject.from_raw(value)
+
+    @staticmethod
+    def from_raw(value: Any):
+        return AnyObject(f"$R({value!r})")
+
+
+def check_expr_at_runtime(original_ast: ast.AST, transformed_ast: ast.AST) -> None:
+    original_externel_symbols = analyze_external_symbols(original_ast)
+    transformed_externel_symbols = analyze_external_symbols(transformed_ast)
+    assert original_externel_symbols == transformed_externel_symbols, "External symbols are different"
+    original_expr = ast.unparse(original_ast)
+    transformed_expr = ast.unparse(transformed_ast)
+    externel_fake_values = {symbol: AnyObject(symbol) for symbol in original_externel_symbols}
+    original_expr_result = eval(original_expr, externel_fake_values)
+    transformed_expr_result = eval(transformed_expr, externel_fake_values)
+    assert repr(original_expr_result) == repr(transformed_expr_result), "Results are different"