Add type-mapping for Records

Author: VijayKandiah

numba_cuda/numba/cuda/core/sigutils.py

@@ -51,6 +51,11 @@ def convert_to_cuda_type(ty):
     if not isinstance(ty, core_types.Type):
         return ty
 
+    # External types (from third-party libraries) should be returned as-is
+    # They have their own typing registrations and shouldn't be converted
+    if hasattr(ty, "__module__") and not ty.__module__.startswith("numba."):
+        return ty
+
     if isinstance(ty, core_types.NumberClass):
         cuda_inner = convert_to_cuda_type(ty.instance_type)
         return types.NumberClass(cuda_inner)
@@ -60,7 +65,21 @@ def convert_to_cuda_type(ty):
         return types.TypeRef(cuda_inner)
 
     if isinstance(ty, core_types.Literal):
-        return ty
+        return types.literal(ty.literal_value)
+
+    if isinstance(ty, core_types.Record):
+        # Convert field types to CUDA types
+        cuda_fields = []
+        for field_name, field_info in ty.fields.items():
+            cuda_field_type = convert_to_cuda_type(field_info.type)
+            cuda_fields.append(
+                (
+                    field_name,
+                    {"type": cuda_field_type, "offset": field_info.offset},
+                )
+            )
+        # Create a cuda.types Record with converted field types
+        return types.Record(cuda_fields, ty.size, ty.aligned)
 
     if isinstance(ty, core_types.Array):
         cuda_dtype = convert_to_cuda_type(ty.dtype)

numba_cuda/numba/cuda/core/typeinfer.py

@@ -51,6 +51,7 @@
 )
 from numba.cuda.core.funcdesc import qualifying_prefix
 from numba.cuda.typeconv import Conversion
+from numba.cuda.core.sigutils import is_numba_type, convert_to_cuda_type
 
 _logger = logging.getLogger(__name__)
 
@@ -79,15 +80,14 @@ def _ensure_cuda_type(self, tp):
         Convert numba.core types to numba.cuda types if necessary.
         This ensures cross-compatibility.
         """
-        from numba.cuda.core.sigutils import is_numba_type, convert_to_cuda_type
 
         if is_numba_type(tp):
             tp = convert_to_cuda_type(tp)
         return tp
 
     def add_type(self, tp, loc):
         tp = self._ensure_cuda_type(tp)
-        assert isinstance(tp, types.Type), type(tp)
+        assert isinstance(tp, types.Type) or is_numba_type(tp), type(tp)
         # Special case for _undef_var.
         # If the typevar is the _undef_var, use the incoming type directly.
         if self.type is types._undef_var:
@@ -122,7 +122,7 @@ def add_type(self, tp, loc):
 
     def lock(self, tp, loc, literal_value=NOTSET):
         tp = self._ensure_cuda_type(tp)
-        assert isinstance(tp, types.Type), type(tp)
+        assert isinstance(tp, types.Type) or is_numba_type(tp), type(tp)
 
         if self.locked:
             msg = (