Merge branch 'ccrouzet/gh-656-struct-inheritance-error-msg' into 'main'

christophercrouzet · christophercrouzet · commit 85de3f6fbbe0 · 2025-05-07T14:08:11.000-07:00
Inform About Class Inheritance Not Being Supported for `wp.struct` (GH-656) See merge request omniverse/warp!1287
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -39,6 +39,8 @@
   averaging the shape's and the cloth's coefficients.
 - Add damping terms for collisions in `wp.sim.VBDIntegrator`, whose strength is controlled by `Model.soft_contact_kd`.
 - Exposed new `warp.fem` operators: `node_count`, `node_index`, `element_coordinates`, `element_closest_point`.
+- Inform about class inheritance not being supported for `wp.struct`
+  ([GH-656](https://github.com/NVIDIA/warp/issues/656)).
 
 ### Fixed
 
diff --git a/docs/limitations.rst b/docs/limitations.rst
@@ -63,6 +63,7 @@ Structs
 -------
 
 * Structs cannot have generic members, i.e. of type ``typing.Any``.
+* Structs do not support inheritance. Consider using composition instead.
 
 Volumes
 -------
diff --git a/warp/codegen.py b/warp/codegen.py
@@ -413,12 +413,15 @@ def numpy_value(self):
 class Struct:
     hash: bytes
 
-    def __init__(self, cls: type, key: str, module: warp.context.Module):
+    def __init__(self, key: str, cls: type, module: warp.context.Module):
+        self.key = key
         self.cls = cls
         self.module = module
-        self.key = key
         self.vars: dict[str, Var] = {}
 
+        if isinstance(self.cls, Sequence):
+            raise RuntimeError("Warp structs must be defined as base classes")
+
         annotations = get_annotations(self.cls)
         for label, type in annotations.items():
             self.vars[label] = Var(label, type)
@@ -489,7 +492,7 @@ class StructType(ctypes.Structure):
 
         self.default_constructor.add_overload(self.value_constructor)
 
-        if module:
+        if isinstance(module, warp.context.Module):
             module.register_struct(self)
 
         # Define class for instances of this struct
diff --git a/warp/context.py b/warp/context.py
@@ -1106,7 +1106,7 @@ def wrapper(f, *args, **kwargs):
 # decorator to register struct, @struct
 def struct(c: type):
     m = get_module(c.__module__)
-    s = warp.codegen.Struct(cls=c, key=warp.codegen.make_full_qualified_name(c), module=m)
+    s = warp.codegen.Struct(key=warp.codegen.make_full_qualified_name(c), cls=c, module=m)
     s = functools.update_wrapper(s, c)
     return s
 
diff --git a/warp/fem/cache.py b/warp/fem/cache.py
@@ -145,8 +145,8 @@ def get_struct(struct: type, suffix: str):
     if key not in _struct_cache:
         module = wp.get_module(struct.__module__)
         _struct_cache[key] = wp.codegen.Struct(
-            cls=struct,
             key=key,
+            cls=struct,
             module=module,
         )
 
diff --git a/warp/sparse.py b/warp/sparse.py
@@ -273,8 +273,8 @@ class BsrMatrixTyped(BsrMatrix):
 
     if key not in _struct_cache:
         _struct_cache[key] = wp.codegen.Struct(
-            cls=BsrMatrixTyped,
             key=key,
+            cls=BsrMatrixTyped,
             module=module,
         )
 
diff --git a/warp/tests/test_builtins_resolution.py b/warp/tests/test_builtins_resolution.py
@@ -189,73 +189,73 @@ def test_mat_mat_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'mat_t, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'mat_t, tuple'$",
             ):
                 wp.ddot(mat_cls(*a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(wpv(dtype, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(wpm(dtype, 3, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(npv(np_type, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(npm(np_type, 3, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'ndarray, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'ndarray, tuple'$",
             ):
                 wp.ddot(np.array(npv(np_type, a_values)), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, mat_t'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, mat_t'$",
             ):
                 wp.ddot(a_values, mat_cls(*b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(a_values, wpv(dtype, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(a_values, wpm(dtype, 3, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(a_values, npv(np_type, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(a_values, npm(np_type, 3, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, ndarray'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, ndarray'$",
             ):
                 wp.ddot(a_values, np.array(npv(np_type, b_values)))
 
@@ -300,37 +300,37 @@ def test_mat_float_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'mat_t, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'mat_t, float'$",
             ):
                 wp.mul(mat_cls(*a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(wpv(dtype, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(wpm(dtype, 3, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(npv(np_type, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(npm(np_type, 3, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'ndarray, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'ndarray, float'$",
             ):
                 wp.mul(np.array(npv(np_type, a_values)), b_value)
 
@@ -401,49 +401,49 @@ def test_vec_vec_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'vec_t, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'vec_t, tuple'$",
             ):
                 wp.dot(vec_cls(*a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.dot(wpv(dtype, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.dot(npv(np_type, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'ndarray, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'ndarray, tuple'$",
             ):
                 wp.dot(np.array(npv(np_type, a_values)), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, vec_t'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, vec_t'$",
             ):
                 wp.dot(a_values, vec_cls(*b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.dot(a_values, wpv(dtype, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.dot(a_values, npv(np_type, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, ndarray'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, ndarray'$",
             ):
                 wp.dot(a_values, np.array(npv(np_type, b_values)))
 
@@ -480,25 +480,25 @@ def test_vec_float_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'vec_t, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'vec_t, float'$",
             ):
                 wp.mul(vec_cls(*a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(wpv(dtype, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(npv(np_type, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'ndarray, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'ndarray, float'$",
             ):
                 wp.mul(np.array(npv(np_type, a_values)), b_value)
 
diff --git a/warp/tests/test_func.py b/warp/tests/test_func.py
@@ -421,7 +421,7 @@ def test_native_function_error_resolution(self):
         b = wp.mat22d(1.0, 2.0, 3.0, 4.0)
         with self.assertRaisesRegex(
             RuntimeError,
-            r"^Couldn't find a function 'mul' compatible with " r"the arguments 'mat22f, mat22d'$",
+            r"^Couldn't find a function 'mul' compatible with the arguments 'mat22f, mat22d'$",
         ):
             a * b
 
diff --git a/warp/tests/test_struct.py b/warp/tests/test_struct.py
@@ -248,6 +248,18 @@ def kernel(foo: Foo):
         )
 
 
+def test_struct_inheritance_error(test, device):
+    with test.assertRaisesRegex(RuntimeError, r"Warp structs must be defined as base classes$"):
+
+        @wp.struct
+        class Parent:
+            x: int
+
+        @wp.struct
+        class Child(Parent):
+            y: int
+
+
 @wp.kernel
 def test_struct_instantiate(data: wp.array(dtype=int)):
     baz = Baz(data, wp.vec3(0.0, 0.0, 26.0))
@@ -682,6 +694,8 @@ def test_nested_vec_assignment(self):
 )
 add_kernel_test(TestStruct, kernel=test_return, name="test_return", dim=1, inputs=[], devices=devices)
 add_function_test(TestStruct, "test_nested_struct", test_nested_struct, devices=devices)
+add_function_test(TestStruct, "test_struct_attribute_error", test_struct_attribute_error, devices=devices)
+add_function_test(TestStruct, "test_struct_inheritance_error", test_struct_inheritance_error, devices=devices)
 add_function_test(TestStruct, "test_nested_array_struct", test_nested_array_struct, devices=devices)
 add_function_test(TestStruct, "test_convert_to_device", test_convert_to_device, devices=devices)
 add_function_test(TestStruct, "test_nested_empty_struct", test_nested_empty_struct, devices=devices)

Original file line number	Diff line number	Diff line change
`@@ -145,8 +145,8 @@ def get_struct(struct: type, suffix: str):`
`145`	`145`	`if key not in _struct_cache:`
`146`	`146`	`module = wp.get_module(struct.__module__)`
`147`	`147`	`_struct_cache[key] = wp.codegen.Struct(`
`148`		`- cls=struct,`
`149`	`148`	`key=key,`
	`149`	`+ cls=struct,`
`150`	`150`	`module=module,`
`151`	`151`	`)`
`152`	`152`
Original file line number	Diff line number	Diff line change
`@@ -273,8 +273,8 @@ class BsrMatrixTyped(BsrMatrix):`
`273`	`273`
`274`	`274`	`if key not in _struct_cache:`
`275`	`275`	`_struct_cache[key] = wp.codegen.Struct(`
`276`		`- cls=BsrMatrixTyped,`
`277`	`276`	`key=key,`
	`277`	`+ cls=BsrMatrixTyped,`
`278`	`278`	`module=module,`
`279`	`279`	`)`
`280`	`280`