Update kernel validation

Author: david-pl

src/bloqade/gemini/analysis/logical_validation/analysis.py

@@ -9,9 +9,9 @@ class GeminiLogicalValidationAnalysis(ValidationAnalysis):
 
     first_gate = True
 
-    def eval_stmt_fallback(self, frame: ValidationFrame, stmt: ir.Statement):
-        if isinstance(stmt, squin.gate.stmts.Gate):
+    def eval_fallback(self, frame: ValidationFrame, node: ir.Statement):
+        if isinstance(node, squin.gate.stmts.Gate):
             # NOTE: to validate that only the first encountered gate can be non-Clifford, we need to track this here
             self.first_gate = False
 
-        return super().eval_stmt_fallback(frame, stmt)
+        return super().eval_fallback(frame, node)

src/bloqade/validation/analysis/analysis.py

@@ -28,14 +28,14 @@ class ValidationAnalysis(ForwardExtra[ValidationFrame, ErrorType], ABC):
 
     lattice = ErrorType
 
-    def run_method(self, method: ir.Method, args: tuple[ErrorType, ...]):
-        return self.run_callable(method.code, (self.lattice.top(),) + args)
-
-    def eval_stmt_fallback(self, frame: ValidationFrame, stmt: ir.Statement):
+    def eval_fallback(self, frame: ValidationFrame, node: ir.Statement):
         # NOTE: default to no errors
-        return tuple(self.lattice.top() for _ in stmt.results)
+        return tuple(self.lattice.top() for _ in node.results)
 
     def initialize_frame(
-        self, code: ir.Statement, *, has_parent_access: bool = False
+        self, node: ir.Statement, *, has_parent_access: bool = False
     ) -> ValidationFrame:
-        return ValidationFrame(code, has_parent_access=has_parent_access)
+        return ValidationFrame(node, has_parent_access=has_parent_access)
+
+    def method_self(self, method: ir.Method) -> ErrorType:
+        return self.lattice.top()

src/bloqade/validation/kernel_validation.py

@@ -48,9 +48,23 @@ class KernelValidation:
     validation_analysis_cls: type[ValidationAnalysis]
     """The analysis that you want to run in order to validate the kernel."""
 
-    def run(self, mt: ir.Method, **kwargs) -> None:
+    def run(self, mt: ir.Method, no_raise: bool = True) -> None:
+        """Run the kernel validation analysis and raise any errors found.
+
+        Args:
+            mt (ir.Method): The method to validate
+            no_raise (bool): Whether or not to raise errors when running the analysis.
+                This is only to make sure the analysis works. Errors found during
+                the analysis will be raised regardless of this setting. Defaults to `True`.
+
+        """
+
         validation_analysis = self.validation_analysis_cls(mt.dialects)
-        validation_frame, _ = validation_analysis.run_analysis(mt, **kwargs)
+
+        if no_raise:
+            validation_frame, _ = validation_analysis.run_no_raise(mt)
+        else:
+            validation_frame, _ = validation_analysis.run(mt)
 
         errors = validation_frame.errors
 

test/gemini/test_logical_validation.py

@@ -30,16 +30,14 @@ def main():
         if m2:
             squin.y(q[2])
 
-    frame, _ = GeminiLogicalValidationAnalysis(main.dialects).run_analysis(
-        main, no_raise=False
-    )
+    frame, _ = GeminiLogicalValidationAnalysis(main.dialects).run_no_raise(main)
 
     main.print(analysis=frame.entries)
 
     validator = KernelValidation(GeminiLogicalValidationAnalysis)
 
     with pytest.raises(ValidationErrorGroup):
-        validator.run(main)
+        validator.run(main, no_raise=False)
 
 
 def test_for_loop():
@@ -104,8 +102,8 @@ def invalid():
             squin.cx(q[0], q[1])
             squin.u3(0.123, 0.253, 1.2, q[0])
 
-        frame, _ = GeminiLogicalValidationAnalysis(invalid.dialects).run_analysis(
-            invalid, no_raise=False
+        frame, _ = GeminiLogicalValidationAnalysis(invalid.dialects).run_no_raise(
+            invalid
         )
 
         invalid.print(analysis=frame.entries)