Better diagnostics for failed DSL compilation/execution

Author: FrancescAlted

examples/ndarray/malformed_dsl.py

@@ -15,7 +15,7 @@
 from blosc2.dsl_kernel import DSLSyntaxError
 
 
-# --- 1) Malformed DSL syntax: validate_dsl() and lazyudf() diagnostics ---
+# --- 1) Malformed DSL syntax: validate_dsl() diagnostics ---
 @blosc2.dsl_kernel
 def kernel_bad_ternary(x):
     return 1 if x else 0
@@ -25,14 +25,15 @@ def kernel_bad_ternary(x):
 print("validate_dsl valid:", report["valid"])
 print("validate_dsl error:\n", report["error"])
 
+# --- 2) Proper error is raised when trying to compute as well ---
+x = blosc2.ones((8, 8), dtype=np.float32)
 try:
-    x = blosc2.ones((8, 8), dtype=np.float32)
-    _ = blosc2.lazyudf(kernel_bad_ternary, (x,), dtype=np.int32)
+    res = blosc2.lazyudf(kernel_bad_ternary, (x,), dtype=np.int32)[:]
 except DSLSyntaxError as e:
     print("\nlazyudf rejected malformed DSL kernel as expected:\n", e)
 
 
-# --- 2) Force miniexpr backend failure to show enriched RuntimeError message ---
+# --- 3) Force miniexpr backend failure to show enriched RuntimeError message ---
 @blosc2.dsl_kernel
 def kernel_ok(x, y):
     return x + y

src/blosc2/dsl_kernel.py

@@ -490,16 +490,20 @@ def __init__(self, func):
         try:
             dsl_source, input_names = self._extract_dsl(func)
         except DSLSyntaxError as e:
-            dsl_source = None
-            input_names = None
+            # Preserve extracted source/signature for diagnostics even when DSL validation fails.
+            try:
+                dsl_source, input_names = self._extract_dsl(func, validate=False)
+            except Exception:
+                dsl_source = None
+                input_names = None
             self.dsl_error = e
         except Exception:
             dsl_source = None
             input_names = None
         self.dsl_source = dsl_source
         self.input_names = input_names
 
-    def _extract_dsl(self, func):
+    def _extract_dsl(self, func, validate: bool = True):
         source = inspect.getsource(func)
         source = textwrap.dedent(source)
         tree = ast.parse(source)
@@ -521,6 +525,8 @@ def _extract_dsl(self, func):
         dsl_func = next((node for node in dsl_tree.body if isinstance(node, ast.FunctionDef)), None)
         if dsl_func is None:
             raise ValueError("No function definition found in sliced DSL source")
+        if validate:
+            _DSLValidator(dsl_source).validate(dsl_func)
         input_names = self._input_names_from_signature(dsl_func)
         if _PRINT_DSL_KERNEL:
             func_name = getattr(func, "__name__", "<dsl_kernel>")

src/blosc2/lazyexpr.py

@@ -1302,9 +1302,9 @@ def _format_dsl_parse_error_hint(expr_text: str, backend_msg: str):
 
 
 def _dsl_miniexpr_required_message(reason: str | None = None) -> str:
-    message = "DSL kernel requires miniexpr."
+    message = ""
     if reason:
-        message = f"{message} {reason}"
+        message = f"{message}{reason}"
     return message
 
 
@@ -1517,7 +1517,9 @@ def fast_eval(  # noqa: C901
         except Exception as e:
             use_miniexpr = False
             if is_dsl:
-                reason = "miniexpr compilation or execution failed for this DSL kernel."
+                reason = (
+                    f"miniexpr compilation or execution failed for this DSL kernel:\n{expression.dsl_source}"
+                )
                 backend_error = str(e)
                 parse_hint = None
                 if isinstance(expr_string_miniexpr, str):

tests/ndarray/test_dsl_kernels.py

@@ -16,6 +16,7 @@
 import pytest
 
 import blosc2
+from blosc2.dsl_kernel import DSLSyntaxError
 from blosc2.lazyexpr import _apply_jit_backend_pragma
 
 where = np.where
@@ -211,7 +212,7 @@ def test_dsl_kernel_integer_ops_kept_as_full_dsl_function():
         res = expr.compute()
     except RuntimeError as e:
         # Some DSL ops may still be unsupported by miniexpr backends.
-        if "DSL kernel requires miniexpr" not in str(e):
+        if "miniexpr compilation or execution failed for this DSL kernel" not in str(e):
             raise
     else:
         expected = kernel_integer_ops.func(a, b)
@@ -537,7 +538,9 @@ def failing_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None,
     try:
         shape = (8, 8)
         expr = blosc2.lazyudf(kernel_scalar_only, (3,), dtype=np.float32, shape=shape)
-        with pytest.raises(RuntimeError, match="DSL kernel requires miniexpr"):
+        with pytest.raises(
+            RuntimeError, match="miniexpr compilation or execution failed for this DSL kernel"
+        ):
             expr.compute()
         assert captured["calls"] >= 1
         assert captured["keys"] == ("__me_dummy0",)
@@ -671,9 +674,13 @@ def failing_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None,
     try:
         _, _, a2, b2 = _make_arrays(shape=(32, 32), chunks=(16, 16), blocks=(8, 8))
         expr = blosc2.lazyudf(kernel_loop, (a2, b2), dtype=a2.dtype)
-        with pytest.raises(RuntimeError, match="DSL kernel requires miniexpr"):
+        with pytest.raises(
+            RuntimeError, match="miniexpr compilation or execution failed for this DSL kernel"
+        ):
             _ = expr.compute()
-        with pytest.raises(RuntimeError, match="DSL kernel requires miniexpr"):
+        with pytest.raises(
+            RuntimeError, match="miniexpr compilation or execution failed for this DSL kernel"
+        ):
             _ = expr.compute(strict_miniexpr=False)
     finally:
         lazyexpr_mod.try_miniexpr = old_try_miniexpr
@@ -694,7 +701,9 @@ def failing_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None,
     try:
         _, _, a2, b2 = _make_arrays(shape=(32, 32), chunks=(16, 16), blocks=(8, 8))
         expr = blosc2.lazyudf(kernel_loop, (a2, b2), dtype=a2.dtype)
-        with pytest.raises(RuntimeError, match="DSL kernel requires miniexpr") as excinfo:
+        with pytest.raises(
+            RuntimeError, match="miniexpr compilation or execution failed for this DSL kernel"
+        ) as excinfo:
             _ = expr.compute()
         msg = str(excinfo.value)
         assert "Backend error: forced miniexpr backend failure details" in msg
@@ -726,7 +735,9 @@ def fake_validate_dsl(_func):
     try:
         _, _, a2, b2 = _make_arrays(shape=(32, 32), chunks=(16, 16), blocks=(8, 8))
         expr = blosc2.lazyudf(kernel_loop, (a2, b2), dtype=a2.dtype)
-        with pytest.raises(RuntimeError, match="DSL kernel requires miniexpr") as excinfo:
+        with pytest.raises(
+            RuntimeError, match="miniexpr compilation or execution failed for this DSL kernel"
+        ) as excinfo:
             _ = expr.compute()
         msg = str(excinfo.value)
         assert "Backend error: forced backend failure hidden by validate_dsl message" in msg
@@ -785,37 +796,35 @@ def test_jit_backend_pragma_wrapping_dsl_source():
 def test_dsl_kernel_flawed_syntax_detected_fallback_callable(kernel):
     assert kernel.dsl_source is not None
     assert kernel.input_names == ["x", "y"]
-    assert kernel.dsl_error is None
+    assert kernel.dsl_error is not None
 
     a, b, a2, b2 = _make_arrays()
-    expr = blosc2.lazyudf(
-        kernel,
-        (a2, b2),
-        dtype=a2.dtype,
-        chunks=a2.chunks,
-        blocks=a2.blocks,
-    )
-    with pytest.raises(RuntimeError, match="DSL kernel requires miniexpr"):
-        _ = expr.compute()
+    with pytest.raises(DSLSyntaxError, match="Invalid DSL kernel"):
+        _ = blosc2.lazyudf(
+            kernel,
+            (a2, b2),
+            dtype=a2.dtype,
+            chunks=a2.chunks,
+            blocks=a2.blocks,
+        )
 
 
 def test_dsl_kernel_ternary_rejected_with_actionable_error():
     assert kernel_fallback_ternary.dsl_source is not None
-    assert kernel_fallback_ternary.dsl_error is None
+    assert kernel_fallback_ternary.input_names == ["x"]
+    assert kernel_fallback_ternary.dsl_error is not None
 
     _, _, a2, _ = _make_arrays()
-    expr = blosc2.lazyudf(
-        kernel_fallback_ternary,
-        (a2,),
-        dtype=np.int32,
-        chunks=a2.chunks,
-        blocks=a2.blocks,
-    )
-    with pytest.raises(RuntimeError, match="DSL kernel requires miniexpr") as excinfo:
-        _ = expr.compute()
+    with pytest.raises(DSLSyntaxError, match="Invalid DSL kernel") as excinfo:
+        _ = blosc2.lazyudf(
+            kernel_fallback_ternary,
+            (a2,),
+            dtype=np.int32,
+            chunks=a2.chunks,
+            blocks=a2.blocks,
+        )
     msg = str(excinfo.value)
-    assert "Backend error:" in msg
-    assert "Parse error location" in msg
+    assert "Ternary expressions are not supported in DSL; use where(cond, a, b)" in msg
     assert "^" in msg
 
 
@@ -827,10 +836,13 @@ def test_validate_dsl_api_valid_and_invalid():
     assert valid_report["input_names"] == ["x", "y"]
 
     unsupported_report = blosc2.validate_dsl(kernel_fallback_ternary)
-    assert unsupported_report["valid"] is True
-    assert unsupported_report["error"] is None
+    assert unsupported_report["valid"] is False
+    assert unsupported_report["error"] is not None
     assert "def kernel_fallback_ternary(x):" in unsupported_report["dsl_source"]
     assert unsupported_report["input_names"] == ["x"]
+    assert (
+        "Ternary expressions are not supported in DSL; use where(cond, a, b)" in unsupported_report["error"]
+    )
 
 
 # ---------------------------------------------------------------------------