Chore: bump mojo to 2025-09-14 version

firebolt/arrays/binary.mojo

@@ -9,7 +9,7 @@ struct StringArray(Array):
     var capacity: Int
 
     fn __init__(out self, var data: ArrayData) raises:
-        if data.dtype != string:
+        if data.dtype != materialize[string]():
             raise Error(
                 "Unexpected dtype '{}' instead of 'string'.".format(data.dtype)
             )
@@ -37,7 +37,7 @@ struct StringArray(Array):
 
         self.capacity = capacity
         self.data = ArrayData(
-            dtype=string,
+            dtype=materialize[string](),
             length=0,
             bitmap=ArcPointer(bitmap^),
             buffers=List(ArcPointer(offsets^), ArcPointer(values^)),

firebolt/arrays/primitive.mojo

@@ -72,9 +72,11 @@ struct PrimitiveArray[T: DataType](Array):
 
     fn __init__(out self, var data: ArrayData, offset: Int = 0) raises:
         # TODO(kszucs): put a dtype constraint here
-        if data.dtype != T:
+        if data.dtype != materialize[T]():
             raise Error(
-                "Unexpected dtype '{}' instead of '{}'.".format(data.dtype, T)
+                "Unexpected dtype '{}' instead of '{}'.".format(
+                    data.dtype, materialize[T]()
+                )
             )
         elif len(data.buffers) != 1:
             raise Error("PrimitiveArray requires exactly one buffer")
@@ -89,7 +91,7 @@ struct PrimitiveArray[T: DataType](Array):
         bitmap = ArcPointer(Bitmap.alloc(capacity))
         buffer = ArcPointer(Buffer.alloc[T.native](capacity))
         self.data = ArrayData(
-            dtype=T,
+            dtype=materialize[T](),
             length=0,
             bitmap=bitmap,
             buffers=List(buffer),
@@ -151,7 +153,7 @@ struct PrimitiveArray[T: DataType](Array):
         var buffer = Buffer.alloc[T.native](size)
         return PrimitiveArray[T](
             data=ArrayData(
-                dtype=T,
+                dtype=materialize[T](),
                 length=size,
                 bitmap=ArcPointer(bitmap^),
                 buffers=List(ArcPointer(buffer^)),
@@ -200,7 +202,7 @@ struct PrimitiveArray[T: DataType](Array):
         """
 
         writer.write("PrimitiveArray( dtype=")
-        writer.write(Self.dtype)
+        writer.write(materialize[Self.dtype]())
         writer.write(", offset=")
         writer.write(self.offset)
         writer.write(", capacity=")

firebolt/arrays/tests/test_base.mojo

@@ -25,7 +25,7 @@ def test_array_data_with_offset():
 
     # Create ArrayData with offset=2
     var array_data = ArrayData(
-        dtype=int8,
+        dtype=materialize[int8](),
         length=3,
         bitmap=bitmap,
         buffers=List(buffer),
@@ -48,15 +48,15 @@ def test_array_data_fieldwise_init():
 
     # Test creating ArrayData with all fields specified including offset
     var array_data = ArrayData(
-        dtype=int8,
+        dtype=materialize[int8](),
         length=5,
         bitmap=bitmap,
         buffers=List(buffer),
         children=List[ArcPointer[ArrayData]](),
         offset=3,
     )
 
-    assert_equal(array_data.dtype, int8)
+    assert_equal(array_data.dtype, materialize[int8]())
     assert_equal(array_data.length, 5)
     assert_equal(array_data.offset, 3)
 
@@ -81,7 +81,7 @@ def test_array_data_write_to_with_offset():
 
         # Create ArrayData with offset=1, so logical indices 0,1,2 map to physical indices 1,2,3
         var array_data = ArrayData(
-            dtype=dtype,
+            dtype=materialize[dtype](),
             length=3,
             bitmap=bitmap,
             buffers=List(buffer),

firebolt/arrays/tests/test_chunked_array.mojo

@@ -17,7 +17,7 @@ def test_chunked_array():
     var second_array_data = build_array_data(2, 0)
     arrays.append(second_array_data^)
 
-    var chunked_array = ChunkedArray(int8, arrays^)
+    var chunked_array = ChunkedArray(materialize[int8](), arrays^)
     assert_equal(chunked_array.length, 3)
 
     assert_equal(chunked_array.chunk(0).length, 1)
@@ -35,13 +35,13 @@ def test_combine_chunked_array():
     var second_array_data = build_array_data(2, 0)
     arrays.append(second_array_data^)
 
-    var chunked_array = ChunkedArray(int8, arrays^)
+    var chunked_array = ChunkedArray(materialize[int8](), arrays^)
     assert_equal(chunked_array.length, 3)
     assert_equal(len(chunked_array.chunks), 2)
     assert_equal(chunked_array.chunk(1).copy().as_uint8().unsafe_get(1), 1)
 
     var combined_array = chunked_array^.combine_chunks()
     assert_equal(combined_array.length, 3)
-    assert_equal(combined_array.dtype, int8)
+    assert_equal(combined_array.dtype, materialize[int8]())
     # Ensure that the last element of the last buffer has the expected value.
     assert_equal(combined_array.buffers[1][].unsafe_get(1), 1)

firebolt/arrays/tests/test_nested.mojo

@@ -20,7 +20,7 @@ fn build_list_of_list[data_type: DataType]() raises -> ListArray:
         buffer[].unsafe_set[data_type.native](i, i + 1)
 
     var value_data = ArrayData(
-        dtype=data_type,
+        dtype=materialize[data_type](),
         length=10,
         bitmap=bitmap,
         buffers=List(buffer),
@@ -42,7 +42,7 @@ fn build_list_of_list[data_type: DataType]() raises -> ListArray:
     list_bitmap[].unsafe_range_set(0, 6, True)
     list_bitmap[].unsafe_set(3, False)
     var list_data = ArrayData(
-        dtype=list_(data_type),
+        dtype=list_(materialize[data_type]()),
         length=6,
         buffers=List(value_offset),
         children=List(ArcPointer(value_data^)),
@@ -60,7 +60,7 @@ fn build_list_of_list[data_type: DataType]() raises -> ListArray:
     top_bitmap[].unsafe_range_set(0, 4, True)
     return ListArray(
         ArrayData(
-            dtype=list_(list_(data_type)),
+            dtype=list_(list_(materialize[data_type]())),
             length=4,
             buffers=List(ArcPointer(top_offsets^)),
             children=List(ArcPointer(list_data^)),
@@ -76,7 +76,7 @@ def test_list_int_array():
     ints.append(2)
     ints.append(3)
     var lists = ListArray(ints^)
-    assert_equal(lists.data.dtype, list_(int64))
+    assert_equal(lists.data.dtype, list_(materialize[int64]()))
 
     var first_value = lists.unsafe_get(0)
     assert_equal(first_value.__str__().strip(), "1 2 3")
@@ -137,9 +137,9 @@ def test_list_of_list():
 
 def test_struct_array():
     var fields = List[Field](
-        Field("id", int64),
-        Field("name", string),
-        Field("active", bool_),
+        Field("id", materialize[int64]()),
+        Field("name", materialize[string]()),
+        Field("active", materialize[bool_]()),
     )
 
     var struct_arr = StructArray(fields^, capacity=10)
@@ -169,8 +169,8 @@ def test_list_array_str_repr():
 
 def test_struct_array_str_repr():
     var fields = List[Field](
-        Field("id", int64),
-        Field("name", string),
+        Field("id", materialize[int64]()),
+        Field("name", materialize[string]()),
     )
 
     var struct_arr = StructArray(fields^, capacity=5)

firebolt/arrays/tests/test_primitive.mojo

@@ -49,7 +49,7 @@ def test_append():
 def test_array_from_ints():
     var g = array[int8](1, 2)
     assert_equal(len(g), 2)
-    assert_equal(g.dtype, int8)
+    assert_equal(materialize[g.dtype](), materialize[int8]())
     assert_equal(g.unsafe_get(0), 1)
     assert_equal(g.unsafe_get(1), 2)
 

firebolt/buffers.mojo

@@ -62,7 +62,7 @@ struct Buffer(Movable):
     @staticmethod
     fn alloc[I: Intable, //, T: DType = DType.uint8](length: I) -> Buffer:
         var size = _required_bytes(Int(length), T)
-        var ptr = UnsafePointer[UInt8, alignment=64].alloc(size)
+        var ptr = UnsafePointer[UInt8].alloc[alignment=64](size)
         memset_zero(ptr.bitcast[UInt8](), size)
         return Buffer(ptr, size)
 

firebolt/c_data.mojo

@@ -56,35 +56,35 @@ struct CArrowSchema(Copyable, Movable, Representable, Stringable, Writable):
         var n_children: Int64 = 0
         var children = UnsafePointer[UnsafePointer[CArrowSchema]]()
 
-        if dtype == null:
+        if dtype == materialize[null]():
             fmt = "n"
-        elif dtype == bool_:
+        elif dtype == materialize[bool_]():
             fmt = "b"
-        elif dtype == int8:
+        elif dtype == materialize[int8]():
             fmt = "c"
-        elif dtype == uint8:
+        elif dtype == materialize[uint8]():
             fmt = "C"
-        elif dtype == int16:
+        elif dtype == materialize[int16]():
             fmt = "s"
-        elif dtype == uint16:
+        elif dtype == materialize[uint16]():
             fmt = "S"
-        elif dtype == int32:
+        elif dtype == materialize[int32]():
             fmt = "i"
-        elif dtype == uint32:
+        elif dtype == materialize[uint32]():
             fmt = "I"
-        elif dtype == int64:
+        elif dtype == materialize[int64]():
             fmt = "l"
-        elif dtype == uint64:
+        elif dtype == materialize[uint64]():
             fmt = "L"
-        elif dtype == float16:
+        elif dtype == materialize[float16]():
             fmt = "e"
-        elif dtype == float32:
+        elif dtype == materialize[float32]():
             fmt = "f"
-        elif dtype == float64:
+        elif dtype == materialize[float64]():
             fmt = "g"
-        elif dtype == binary:
+        elif dtype == materialize[binary]():
             fmt = "z"
-        elif dtype == string:
+        elif dtype == materialize[string]():
             fmt = "u"
         elif dtype.is_struct():
             print("EEE")
@@ -139,35 +139,35 @@ struct CArrowSchema(Copyable, Movable, Representable, Stringable, Writable):
         )
         # TODO(kszucs): not the nicest, but dictionary literals are not supported yet
         if fmt == "n":
-            return null
+            return materialize[null]()
         elif fmt == "b":
-            return bool_
+            return materialize[bool_]()
         elif fmt == "c":
-            return int8
+            return materialize[int8]()
         elif fmt == "C":
-            return uint8
+            return materialize[uint8]()
         elif fmt == "s":
-            return int16
+            return materialize[int16]()
         elif fmt == "S":
-            return uint16
+            return materialize[uint16]()
         elif fmt == "i":
-            return int32
+            return materialize[int32]()
         elif fmt == "I":
-            return uint32
+            return materialize[uint32]()
         elif fmt == "l":
-            return int64
+            return materialize[int64]()
         elif fmt == "L":
-            return uint64
+            return materialize[uint64]()
         elif fmt == "e":
-            return float16
+            return materialize[float16]()
         elif fmt == "f":
-            return float32
+            return materialize[float32]()
         elif fmt == "g":
-            return float64
+            return materialize[float64]()
         elif fmt == "z":
-            return binary
+            return materialize[binary]()
         elif fmt == "u":
-            return string
+            return materialize[string]()
         elif fmt == "+l":
             var field = self.children[0][].to_field()
             return list_(field.dtype.copy())
@@ -251,10 +251,10 @@ struct CArrowArray(Copyable, Movable):
             bitmap[].unsafe_range_set(0, self.length, True)
 
         var buffers = List[ArcPointer[Buffer]]()
-        if dtype.is_numeric() or dtype == bool_:
+        if dtype.is_numeric() or dtype == materialize[bool_]():
             var buffer = Buffer.view(self.buffers[1], self.length, dtype.native)
             buffers.append(ArcPointer(buffer^))
-        elif dtype == string:
+        elif dtype == materialize[string]():
             var offsets = Buffer.view(
                 self.buffers[1], self.length + 1, DType.uint32
             )

firebolt/test_fixtures/arrays.mojo

@@ -38,7 +38,7 @@ def build_array_data(length: Int, nulls: Int) -> ArrayData:
 
     var buffers = List(ArcPointer(buffer^))
     return ArrayData(
-        dtype=uint8,
+        dtype=materialize[uint8](),
         length=length,
         bitmap=ArcPointer(bitmap^),
         buffers=buffers^,