Improve errors (#47)

* Work on improving error information

* Better runtime error handling + highlighted parameter

* Add version number fixup

* Update SlangPy->0.19.2, SGL->0.12.3

* Fix incorrect exceptions

Author: ccummingsNV

docs/changelog.rst

@@ -1,6 +1,12 @@
 Changelog
 ---------
 
+**Version 0.19.2**
+- Update SGL -> 0.12.3
+- Better error messages during generation
+- Fix corrupt error tables 
+- Restore detailed error information during dispatch
+
 **Version 0.19.1**
 - Update SGL -> 0.12.2
 - Fix major issue with texture transposes

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slangpy"
-version = "0.19.1"
+version = "0.19.2"
 authors = [
     {name = "Chris Cummings", email = "[email protected]"},
     {name = "Benedikt Bitterli", email = "[email protected]"},
@@ -17,7 +17,7 @@ requires-python = ">=3.9"
 dependencies = [
   "typing_extensions",
   "numpy",
-  "nv-sgl==0.12.2"
+  "nv-sgl==0.12.3"
 ]
 
 [tool.pyright]

requirements-dev.txt

@@ -1,6 +1,6 @@
 typing_extensions
 numpy
-nv-sgl == 0.12.2
+nv-sgl == 0.12.3
 
 pre-commit
 pytest

requirements.txt

@@ -1,3 +1,3 @@
 typing_extensions
 numpy
-nv-sgl == 0.12.2
+nv-sgl == 0.12.3

slangpy/core/calldata.py

@@ -108,13 +108,13 @@ def __init__(
             slang_function = specialize(
                 context, bindings, build_info.reflections, build_info.type_reflection)
             if isinstance(slang_function, MismatchReason):
-                raise KernelGenException(
+                raise ResolveException(
                     f"Function signature mismatch: {slang_function.reason}\n\n"
                     f"{mismatch_info(bindings, build_info.reflections)}\n")
 
             # Check for differentiability error
             if not slang_function.differentiable and self.call_mode != CallMode.prim:
-                raise KernelGenException(
+                raise ResolveException(
                     f"Could not call function '{function.name}': Function is not differentiable\n\n"
                     f"{mismatch_info(bindings, build_info.reflections)}\n")
 
@@ -220,34 +220,37 @@ def __init__(
                     slang_function, SlangFunction) else build_info.reflections[0]
                 raise ValueError(
                     f"{e.message}\n\n"
-                    f"{bound_exception_info(bindings, ref, e.variable)}\n")
+                    f"{bound_exception_info(bindings, ref, e.variable)}\n") from e
             else:
-                raise e
+                raise
         except SlangCompileError as e:
             if bindings is not None:
                 ref = slang_function.reflection if isinstance(
                     slang_function, SlangFunction) else build_info.reflections[0]
                 raise ValueError(
-                    f"Slang compilation error: {e}\n. See .temp directory for generated shader.\n"
-                    f"This most commonly occurs as a result of an invalid explicit type cast, or bug in implicit casting logic.\n"
-                    f"{bound_exception_info(bindings, ref, None)}\n")
+                    f"Slang compilation error: {e}\n. Use set_dump_generated_shaders to enable dump generated shader to .temp.\n"
+                    f"This most commonly occurs as a result of an invalid explicit type cast, or bug in implicit casting logic.\n\n"
+                    f"{bound_exception_info(bindings, ref, None)}\n") from e
             else:
                 raise e
         except KernelGenException as e:
             if bindings is not None:
                 ref = slang_function.reflection if isinstance(
                     slang_function, SlangFunction) else build_info.reflections[0]
                 raise ValueError(
-                    f"Exception in kernel generation: {e.message}\n."
-                    f"{bound_exception_info(bindings, ref, None)}\n")
+                    f"Exception in kernel generation: {e.message}.\n\n"
+                    f"{bound_exception_info(bindings, ref, None)}\n") from e
             else:
                 raise e
+        except ResolveException as e:
+            # Triggered from within calldata, doesn't need augmenting
+            raise e
         except Exception as e:
             if bindings is not None:
                 ref = slang_function.reflection if isinstance(
                     slang_function, SlangFunction) else build_info.reflections[0]
                 raise ValueError(
-                    f"Exception in kernel generation: {e}\n."
-                    f"{bound_exception_info(bindings, ref, None)}\n")
+                    f"Exception in kernel generation: {e}.\n"
+                    f"{bound_exception_info(bindings, ref, None)}\n") from e
             else:
                 raise e

slangpy/core/callsignature.py

@@ -25,6 +25,12 @@ def __init__(self, reason: str):
         self.reason = reason
 
 
+class ResolveException(Exception):
+    def __init__(self, message: str):
+        super().__init__(message)
+        self.message = message
+
+
 class KernelGenException(Exception):
     def __init__(self, message: str):
         super().__init__(message)
@@ -84,7 +90,7 @@ def specialize(
 
     if signature.num_function_kwargs > 0 or signature.has_implicit_args:
         if function.is_overloaded:
-            return MismatchReason("Call an overloaded function with named or implicit arguments is not currently supported.")
+            return MismatchReason("Calling an overloaded function with named or implicit arguments is not currently supported.")
 
         function_parameters = [x for x in function.parameters]
 
@@ -195,14 +201,18 @@ def to_type_reflection(input: Any) -> TypeReflection:
                 f"After implicit casting, cannot convert {input} to TypeReflection.")
 
     types = [to_type_reflection(x.vector_type) for x in root_params]
-    if any(x is None for x in types):
-        raise KernelGenException(
-            "After implicit casting, unable to resolve all Slang types for specialization overload resolution.")
+    for (type, param) in zip(types, root_params):
+        if type is None:
+            raise KernelGenException(
+                f"After implicit casting, unable to find reflection data for {param.variable_name}"
+                "This typically suggests the binding system has attempted to generate an invalid Slang type.")
 
     specialized = function.reflection.specialize_with_arg_types(types)
     if specialized is None:
         raise KernelGenException(
-            "After implicit casting, no Slang overload found that matches the provided Python argument types.")
+            "After implicit casting, no Slang overload found that matches the provided Python argument types. "
+            "This typically suggests SlangPy selected an overload to call, but couldn't find a valid "
+            "way to pass your Python arguments to it.")
 
 
 def bind(

slangpy/core/function.py

@@ -205,7 +205,24 @@ def call(self, *args: Any, **kwargs: Any) -> Any:
             del kwargs['_result']
             return self.return_type(resval).call(*args, **kwargs)
         else:
-            return self._native_call(self.module.call_data_cache, *args, **kwargs)
+            try:
+                return self._native_call(self.module.call_data_cache, *args, **kwargs)
+            except ValueError as e:
+                # If runtime returned useful information, reformat it and raise a new exception
+                # Otherwise just throw the original.
+                if len(e.args) != 1 or not isinstance(e.args[0], dict) or not 'message' in e.args[0] or not 'source' in e.args[0] or not 'context' in e.args[0]:
+                    raise
+                from slangpy.bindings.boundvariableruntime import BoundVariableRuntime
+                from slangpy.core.native import NativeCallData
+                from slangpy.core.logging import bound_runtime_call_table
+                msg: str = e.args[0]['message']
+                source: BoundVariableRuntime = e.args[0]['source']
+                context: NativeCallData = e.args[0]['context']
+                runtime = context.runtime
+                msg += "\n\n" + \
+                    bound_runtime_call_table(runtime, source) + \
+                    "\n\nFor help and support: https://khr.io/slangdiscord"
+                raise ValueError(msg) from e
 
     def append_to(self, command_buffer: CommandBuffer, *args: Any, **kwargs: Any):
         """

slangpy/core/logging.py

@@ -68,7 +68,7 @@ def _generate_table_recurse(data: list[Any], columns: list[TableColumn], depth:
         row_str = " | ".join(cols)
 
         if row == highlight:
-            row_str = f"\033[1;32;40m{row_str}\033[0m"
+            row_str += "<-------"
 
         rows.append(row_str)
         children = children_id(row)
@@ -139,7 +139,7 @@ def bound_call_table(data: 'BoundCall', highlight: Optional['BoundVariable'] = N
 def bound_runtime_variables_table(data: list['BoundVariableRuntime'], highlight: Optional['BoundVariableRuntime'] = None, filter: Optional[dict[str, bool]] = None):
     columns = [
         TableColumn("Name", 20, lambda x: _pyarg_name(x._source_for_exceptions.name)),
-        TableColumn("Index", 10, "param_index"),
+        TableColumn("Index", 10, lambda x: x._source_for_exceptions.param_index),
         TableColumn("PyType", 30, lambda x: _type_name(x._source_for_exceptions.python)),
         TableColumn("SlType", 30, lambda x: _type_name(
             x._source_for_exceptions.slang_type)),
@@ -206,6 +206,7 @@ def mismatch_info(call: 'BoundCall', reflections: list[FunctionReflection]):
     text.append("")
     text.append(f"Python arguments:")
     text.append(f"{bound_call_table(call)}")
+    text.append(f"For help and support: https://khr.io/slangdiscord")
 
     return "\n".join(text)
 
@@ -214,9 +215,14 @@ def bound_exception_info(call: 'BoundCall', concrete_reflection: FunctionReflect
     text: list[str] = []
 
     text.append(f"Selected overload:")
-    text.append(f"{function_reflection(concrete_reflection)}")
+    text.append(f"  {function_reflection(concrete_reflection)}")
     text.append("")
+    if variable is not None and variable.name != "":
+        text.append(f"Error caused by argument: {variable.name}")
+        text.append("")
     text.append(f"Python arguments:")
     text.append(f"{bound_call_table(call, highlight=variable)}")
+    text.append("")
+    text.append(f"For help and support: https://khr.io/slangdiscord")
 
     return "\n".join(text)

slangpy/tests/test_differential_function_call.py

@@ -62,7 +62,7 @@ def test_call_none_differentiable(device_type: DeviceType):
     res = function(a, b)
     assert res == python_eval_polynomial(a, b)
 
-    with pytest.raises(ValueError, match="Could not call function 'polynomial': Function is not differentiable"):
+    with pytest.raises(Exception, match="Could not call function 'polynomial': Function is not differentiable"):
         function.bwds(a, b, res)
 
 

slangpy/tests/test_errors.py

@@ -24,7 +24,7 @@ def test_no_matching_arg_count(device_type: DeviceType):
     device = helpers.get_device(device_type)
     function = helpers.create_function_from_module(device, "foo", MODULE)
 
-    with pytest.raises(ValueError, match=r'Too many positional arguments'):
+    with pytest.raises(Exception, match=r'Too many positional arguments'):
         function.call(1.0, 2.0)
 
 
@@ -34,7 +34,7 @@ def test_no_matching_arg_name(device_type: DeviceType):
     device = helpers.get_device(device_type)
     function = helpers.create_function_from_module(device, "foo", MODULE)
 
-    with pytest.raises(ValueError, match=r'No parameter named'):
+    with pytest.raises(Exception, match=r'No parameter named'):
         function.call(b=10.0)
 
 
@@ -46,7 +46,7 @@ def test_not_enough_args(device_type: DeviceType):
 
     # note: due to no implicit args, falls straight through to slang resolution which provides
     # no special error info yet
-    with pytest.raises(ValueError, match=r'No Slang overload found'):
+    with pytest.raises(Exception, match=r'No Slang overload found'):
         function.call()
 
 
@@ -56,7 +56,7 @@ def test_not_enough_args_2(device_type: DeviceType):
     device = helpers.get_device(device_type)
     function = helpers.create_function_from_module(device, "foo2", MODULE)
 
-    with pytest.raises(ValueError, match=r'all parameters must be specified'):
+    with pytest.raises(Exception, match=r'all parameters must be specified'):
         function.call(10.0)
 
 
@@ -66,7 +66,7 @@ def test_specify_twice(device_type: DeviceType):
     device = helpers.get_device(device_type)
     function = helpers.create_function_from_module(device, "foo2", MODULE)
 
-    with pytest.raises(ValueError, match=r'already specified'):
+    with pytest.raises(Exception, match=r'already specified'):
         function.call(10.0, a=20.0)
 
 
@@ -76,7 +76,7 @@ def test_implicit_overload(device_type: DeviceType):
     device = helpers.get_device(device_type)
     function = helpers.create_function_from_module(device, "foo_ol", MODULE)
 
-    with pytest.raises(ValueError, match=r'overloaded function with named or implicit arguments'):
+    with pytest.raises(Exception, match=r'overloaded function with named or implicit arguments'):
         function.call(10.0)
 
 
@@ -129,5 +129,19 @@ def test_invalid_broadcast(device_type: DeviceType):
         function(buffer, buffer2)
 
 
+@pytest.mark.parametrize("device_type", helpers.DEFAULT_DEVICE_TYPES)
+def test_invalid_broadcast_during_dispatch(device_type: DeviceType):
+
+    device = helpers.get_device(device_type)
+    function = helpers.create_function_from_module(device, "foo2", MODULE)
+
+    buffer = NDBuffer(device, dtype=float, shape=(10, 5))
+    buffer2 = NDBuffer(device, dtype=float, shape=(10, 10))
+
+    # fail to specialize a float3 against a float
+    with pytest.raises(ValueError, match=r'Shape mismatch'):
+        function(buffer, buffer2)
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])