even more underfined -> null

Author: CGQAQ

src/allocators.zig

@@ -195,7 +195,7 @@ pub fn BSSList(comptime ValueType: type, comptime _count: anytype) type {
 
         allocator: Allocator,
         mutex: Mutex = Mutex.init(),
-        head: *OverflowBlock = undefined,
+        head: ?*OverflowBlock = null,
         tail: OverflowBlock = OverflowBlock{},
         backing_buf: [count]ValueType = undefined,
         used: u32 = 0,
@@ -230,12 +230,12 @@ pub fn BSSList(comptime ValueType: type, comptime _count: anytype) type {
 
         fn appendOverflow(self: *Self, value: ValueType) !*ValueType {
             instance.used += 1;
-            return self.head.append(value) catch brk: {
+            return self.head.?.append(value) catch brk: {
                 var new_block = try self.allocator.create(OverflowBlock);
                 new_block.* = OverflowBlock{};
                 new_block.prev = self.head;
                 self.head = new_block;
-                break :brk self.head.append(value);
+                break :brk self.head.?.append(value);
             };
         }
 

src/baby_list.zig

@@ -8,7 +8,7 @@ const bun = @import("root").bun;
 pub fn BabyList(comptime Type: type) type {
     return struct {
         const ListType = @This();
-        ptr: [*]Type = undefined,
+        ptr: ?[*]Type = null,
         len: u32 = 0,
         cap: u32 = 0,
 
@@ -21,7 +21,7 @@ pub fn BabyList(comptime Type: type) type {
         }
 
         pub fn available(this: *@This()) []Type {
-            return this.ptr[this.len..this.cap];
+            return this.ptr.?[this.len..this.cap];
         }
 
         pub fn deinitWithAllocator(this: *@This(), allocator: std.mem.Allocator) void {
@@ -30,7 +30,7 @@ pub fn BabyList(comptime Type: type) type {
         }
 
         pub fn contains(this: @This(), item: []const Type) bool {
-            return this.len > 0 and @intFromPtr(item.ptr) >= @intFromPtr(this.ptr) and @intFromPtr(item.ptr) < @intFromPtr(this.ptr) + this.len;
+            return this.len > 0 and @intFromPtr(item.ptr) >= @intFromPtr(this.ptr.?) and @intFromPtr(item.ptr) < @intFromPtr(this.ptr.?) + this.len;
         }
 
         pub inline fn initConst(items: []const Type) ListType {
@@ -52,7 +52,7 @@ pub fn BabyList(comptime Type: type) type {
         pub fn popOrNull(this: *@This()) ?Type {
             if (this.len == 0) return null;
             this.len -= 1;
-            return this.ptr[this.len];
+            return this.ptr.?[this.len];
         }
 
         pub fn clone(this: @This(), allocator: std.mem.Allocator) !@This() {
@@ -66,7 +66,7 @@ pub fn BabyList(comptime Type: type) type {
         }
 
         pub fn appendAssumeCapacity(this: *@This(), value: Type) void {
-            this.ptr[this.len] = value;
+            this.ptr.?[this.len] = value;
             this.len += 1;
             std.debug.assert(this.cap >= this.len);
         }
@@ -81,7 +81,7 @@ pub fn BabyList(comptime Type: type) type {
         }
 
         pub fn appendSliceAssumeCapacity(this: *@This(), values: []const Type) void {
-            var tail = this.ptr[this.len .. this.len + values.len];
+            var tail = this.ptr.?[this.len .. this.len + values.len];
             std.debug.assert(this.cap >= this.len + @as(u32, @truncate(values.len)));
             bun.copy(Type, tail, values);
             this.len += @as(u32, @truncate(values.len));
@@ -154,39 +154,39 @@ pub fn BabyList(comptime Type: type) type {
 
         pub fn list(this: ListType) std.ArrayListUnmanaged(Type) {
             return std.ArrayListUnmanaged(Type){
-                .items = this.ptr[0..this.len],
+                .items = this.ptr.?[0..this.len],
                 .capacity = this.cap,
             };
         }
 
         pub fn listManaged(this: ListType, allocator: std.mem.Allocator) std.ArrayList(Type) {
             return std.ArrayList(Type){
-                .items = this.ptr[0..this.len],
+                .items = this.ptr.?[0..this.len],
                 .capacity = this.cap,
                 .allocator = allocator,
             };
         }
 
         pub inline fn first(this: ListType) ?*Type {
-            return if (this.len > 0) this.ptr[0] else @as(?*Type, null);
+            return if (this.len > 0) this.ptr.?[0] else @as(?*Type, null);
         }
 
         pub inline fn last(this: ListType) ?*Type {
-            return if (this.len > 0) &this.ptr[this.len - 1] else @as(?*Type, null);
+            return if (this.len > 0) &this.ptr.?[this.len - 1] else @as(?*Type, null);
         }
 
         pub inline fn first_(this: ListType) Type {
-            return this.ptr[0];
+            return this.ptr.?[0];
         }
 
         pub inline fn at(this: ListType, index: usize) *const Type {
             std.debug.assert(index < this.len);
-            return &this.ptr[index];
+            return &this.ptr.?[index];
         }
 
         pub inline fn mut(this: ListType, index: usize) *Type {
             std.debug.assert(index < this.len);
-            return &this.ptr[index];
+            return &this.ptr.?[index];
         }
 
         pub fn one(allocator: std.mem.Allocator, value: Type) !ListType {
@@ -200,7 +200,7 @@ pub fn BabyList(comptime Type: type) type {
         }
 
         pub inline fn @"[0]"(this: ListType) Type {
-            return this.ptr[0];
+            return this.ptr.?[0];
         }
         const OOM = error{OutOfMemory};
 
@@ -218,7 +218,7 @@ pub fn BabyList(comptime Type: type) type {
 
         pub inline fn slice(this: ListType) []Type {
             @setRuntimeSafety(false);
-            return this.ptr[0..this.len];
+            return this.ptr.?[0..this.len];
         }
 
         pub fn write(this: *@This(), allocator: std.mem.Allocator, str: []const u8) !u32 {

src/bun.js/base.zig

@@ -394,7 +394,7 @@ pub fn dump(value: JSValue, globalObject: *JSC.JSGlobalObject) !void {
 pub const JSStringList = std.ArrayList(js.JSStringRef);
 
 pub const ArrayBuffer = extern struct {
-    ptr: [*]u8 = undefined,
+    ptr: ?[*]u8 = null,
     offset: u32 = 0,
     len: u32 = 0,
     byte_len: u32 = 0,
@@ -586,7 +586,7 @@ pub const ArrayBuffer = extern struct {
     ///    new ArrayBuffer(view.buffer, view.byteOffset, view.byteLength)
     /// ```
     pub inline fn byteSlice(this: *const @This()) []u8 {
-        return this.ptr[this.offset .. this.offset + this.byte_len];
+        return this.ptr.?[this.offset .. this.offset + this.byte_len];
     }
 
     /// The equivalent of

src/bun.js/event_loop.zig

@@ -365,12 +365,12 @@ const AsyncIO = @import("root").bun.AsyncIO;
 
 // This type must be unique per JavaScript thread
 pub const GarbageCollectionController = struct {
-    gc_timer: *uws.Timer = undefined,
+    gc_timer: ?*uws.Timer = null,
     gc_last_heap_size: usize = 0,
     gc_last_heap_size_on_repeating_timer: usize = 0,
     heap_size_didnt_change_for_repeating_timer_ticks_count: u8 = 0,
     gc_timer_state: GCTimerState = GCTimerState.pending,
-    gc_repeating_timer: *uws.Timer = undefined,
+    gc_repeating_timer: ?*uws.Timer = null,
     gc_timer_interval: i32 = 0,
     gc_repeating_timer_fast: bool = true,
 
@@ -387,13 +387,13 @@ pub const GarbageCollectionController = struct {
                 }
             } else |_| {}
         }
-        this.gc_repeating_timer.set(this, onGCRepeatingTimer, gc_timer_interval, gc_timer_interval);
+        this.gc_repeating_timer.?.set(this, onGCRepeatingTimer, gc_timer_interval, gc_timer_interval);
         this.gc_timer_interval = gc_timer_interval;
     }
 
     pub fn scheduleGCTimer(this: *GarbageCollectionController) void {
         this.gc_timer_state = .scheduled;
-        this.gc_timer.set(this, onGCTimer, 16, 0);
+        this.gc_timer.?.set(this, onGCTimer, 16, 0);
     }
 
     pub fn bunVM(this: *GarbageCollectionController) *VirtualMachine {
@@ -419,11 +419,11 @@ pub const GarbageCollectionController = struct {
     pub fn updateGCRepeatTimer(this: *GarbageCollectionController, comptime setting: @Type(.EnumLiteral)) void {
         if (setting == .fast and !this.gc_repeating_timer_fast) {
             this.gc_repeating_timer_fast = true;
-            this.gc_repeating_timer.set(this, onGCRepeatingTimer, this.gc_timer_interval, this.gc_timer_interval);
+            this.gc_repeating_timer.?.set(this, onGCRepeatingTimer, this.gc_timer_interval, this.gc_timer_interval);
             this.heap_size_didnt_change_for_repeating_timer_ticks_count = 0;
         } else if (setting == .slow and this.gc_repeating_timer_fast) {
             this.gc_repeating_timer_fast = false;
-            this.gc_repeating_timer.set(this, onGCRepeatingTimer, 30_000, 30_000);
+            this.gc_repeating_timer.?.set(this, onGCRepeatingTimer, 30_000, 30_000);
             this.heap_size_didnt_change_for_repeating_timer_ticks_count = 0;
         }
     }

src/bun.js/test/snapshot.zig

@@ -153,8 +153,8 @@ pub const Snapshots = struct {
 
         if (export_default.data == .e_call) {
             const function_call = export_default.data.e_call;
-            if (function_call.args.len == 2 and function_call.args.ptr[0].data == .e_function) {
-                const arg_function_stmts = function_call.args.ptr[0].data.e_function.func.body.stmts;
+            if (function_call.args.len == 2 and function_call.args.ptr.?[0].data == .e_function) {
+                const arg_function_stmts = function_call.args.ptr.?[0].data.e_function.func.body.stmts;
                 for (arg_function_stmts) |stmt| {
                     switch (stmt.data) {
                         .s_expr => |expr| {

src/bun.js/webcore/encoding.zig

@@ -205,7 +205,7 @@ pub const TextEncoder = struct {
         if (array.isEmpty()) {
             array = JSC.JSValue.createUninitializedUint8Array(globalThis, length);
             array.ensureStillAlive();
-            @memcpy(array.asArrayBuffer(globalThis).?.ptr[0..length], buf_to_use[0..length]);
+            @memcpy(array.asArrayBuffer(globalThis).?.ptr.?[0..length], buf_to_use[0..length]);
         }
 
         return array;

src/bun.js/webcore/streams.zig

@@ -2534,7 +2534,7 @@ pub fn HTTPServerWritable(comptime ssl: bool) type {
         }
 
         fn readableSlice(this: *@This()) []const u8 {
-            return this.buffer.ptr[this.offset..this.buffer.cap][0..this.buffer.len];
+            return this.buffer.ptr.?[this.offset..this.buffer.cap][0..this.buffer.len];
         }
 
         pub fn onWritable(this: *@This(), write_offset_: c_ulong, _: *UWSResponse) callconv(.C) bool {
@@ -3760,16 +3760,16 @@ pub const AutoSizer = struct {
 
     pub fn resize(this: *AutoSizer, size: usize) ![]u8 {
         const available = this.buffer.cap - this.buffer.len;
-        if (available >= size) return this.buffer.ptr[this.buffer.len..this.buffer.cap][0..size];
+        if (available >= size) return this.buffer.ptr.?[this.buffer.len..this.buffer.cap][0..size];
         const to_grow = size -| available;
         if (to_grow + @as(usize, this.buffer.cap) > this.max)
-            return this.buffer.ptr[this.buffer.len..this.buffer.cap];
+            return this.buffer.ptr.?[this.buffer.len..this.buffer.cap];
 
         var list = this.buffer.listManaged(this.allocator);
         const prev_len = list.items.len;
         try list.ensureTotalCapacity(to_grow + @as(usize, this.buffer.cap));
         this.buffer.update(list);
-        return this.buffer.ptr[prev_len..@as(usize, this.buffer.cap)];
+        return this.buffer.ptr.?[prev_len..@as(usize, this.buffer.cap)];
     }
 };
 

src/bun.zig

@@ -534,6 +534,15 @@ pub fn clone(val: anytype, allocator: std.mem.Allocator) !@TypeOf(val) {
 }
 pub const StringBuilder = @import("./string_builder.zig");
 
+/// This is wrong! Avoid using this!
+/// Any use of this should be replaced with the type itself to the optional type.
+/// The undefind is unspecified value, cant be compared to anything include itself.
+/// In Debug mode,
+/// Zig writes 0xaa bytes to undefined memory.
+/// This is to catch bugs early, and to help detect use of undefined memory in a debugger.
+///   However, this behavior is only an implementation feature, not a language semantic,
+///   so it is not guaranteed to be *observable* to code.
+/// ref: https://ziglang.org/documentation/master/#undefined
 pub fn assertDefined(val: anytype) void {
     if (comptime !Environment.allow_assert) return;
     const Type = @TypeOf(val);

src/bun_dev_http_server.zig

@@ -103,7 +103,7 @@ const PosixRequestContext = struct {
     conn: std.net.Stream,
     allocator: std.mem.Allocator,
     arena: ThreadlocalArena,
-    req_body_node: *RequestDataPool.Node = undefined,
+    req_body_node: ?*RequestDataPool.Node = null,
     log: logger.Log,
     bundler: *Bundler,
     keep_alive: bool = true,
@@ -1252,7 +1252,7 @@ const PosixRequestContext = struct {
         const CacheSet = @import("./cache.zig").Set;
         threadlocal var websocket_printer: JSPrinter.BufferWriter = undefined;
         pub fn handle(self: *WebsocketHandler) void {
-            var req_body = self.ctx.req_body_node;
+            var req_body = self.ctx.req_body_node.?;
             defer {
                 js_ast.Stmt.Data.Store.reset();
                 js_ast.Expr.Data.Store.reset();
@@ -3045,7 +3045,7 @@ pub const Server = struct {
 
         defer {
             if (!req_ctx.controlled) {
-                req_ctx.req_body_node.release();
+                req_ctx.req_body_node.?.release();
                 req_ctx.arena.deinit();
             }
         }

src/bundler/bundle_v2.zig

@@ -3179,7 +3179,7 @@ const LinkerGraph = struct {
             .top_level_symbol_to_parts_overlay = &top_level_symbol_to_parts_overlay,
         };
 
-        js_ast.DeclaredSymbol.forEachTopLevelSymbol(&parts.ptr[part_id].declared_symbols, &ctx, Iterator.next);
+        js_ast.DeclaredSymbol.forEachTopLevelSymbol(&parts.ptr.?[part_id].declared_symbols, &ctx, Iterator.next);
 
         return part_id;
     }
@@ -4212,7 +4212,7 @@ const LinkerContext = struct {
             @panic("Internal error: expected at least one part for lazy export");
         }
 
-        var part: *js_ast.Part = &parts.ptr[1];
+        var part: *js_ast.Part = &parts.ptr.?[1];
 
         if (part.stmts.len == 0) {
             @panic("Internal error: expected at least one statement in the lazy export");
@@ -4278,8 +4278,8 @@ const LinkerContext = struct {
                         // end up actually being used at this point (since import binding hasn't
                         // happened yet). So we need to wait until after tree shaking happens.
                         const generated = try this.generateNamedExportInFile(source_index, module_ref, name, name);
-                        parts.ptr[generated[1]].stmts = this.allocator.alloc(Stmt, 1) catch unreachable;
-                        parts.ptr[generated[1]].stmts[0] = Stmt.alloc(
+                        parts.ptr.?[generated[1]].stmts = this.allocator.alloc(Stmt, 1) catch unreachable;
+                        parts.ptr.?[generated[1]].stmts[0] = Stmt.alloc(
                             S.Local,
                             S.Local{
                                 .is_export = true,
@@ -4315,8 +4315,8 @@ const LinkerContext = struct {
                         ) catch unreachable,
                         "default",
                     );
-                    parts.ptr[generated[1]].stmts = this.allocator.alloc(Stmt, 1) catch unreachable;
-                    parts.ptr[generated[1]].stmts[0] = Stmt.alloc(
+                    parts.ptr.?[generated[1]].stmts = this.allocator.alloc(Stmt, 1) catch unreachable;
+                    parts.ptr.?[generated[1]].stmts[0] = Stmt.alloc(
                         S.ExportDefault,
                         S.ExportDefault{
                             .default_name = .{
@@ -7961,7 +7961,7 @@ const LinkerContext = struct {
                             stmt.data.s_local.is_export = false;
                         } else if (FeatureFlags.unwrap_commonjs_to_esm and s.was_commonjs_export and wrap == .cjs) {
                             std.debug.assert(stmt.data.s_local.decls.len == 1);
-                            const decl = stmt.data.s_local.decls.ptr[0];
+                            const decl = stmt.data.s_local.decls.ptr.?[0];
                             if (decl.value) |decl_value| {
                                 stmt = Stmt.alloc(
                                     S.SExpr,

src/cli/create_command.zig

@@ -1167,7 +1167,7 @@ pub const CreateCommand = struct {
                     // "bun.macros.react-relay.graphql"
                     if (needs.bun_macro_relay and !needs_bun_prop and !needs_bun_macros_prop) {
                         // "graphql" is the only valid one for now, so anything else in this object is invalid.
-                        bun_relay_prop.?.data.e_object = InjectionPrefill.bun_macros_relay_object.properties.ptr[0].value.?.data.e_object;
+                        bun_relay_prop.?.data.e_object = InjectionPrefill.bun_macros_relay_object.properties.ptr.?[0].value.?.data.e_object;
                         needs_bun_macros_prop = false;
                         needs_bun_prop = false;
                         needs.bun_macro_relay = false;
@@ -1339,7 +1339,7 @@ pub const CreateCommand = struct {
                     var i: usize = 0;
                     var property_i: usize = 0;
                     while (i < package_json_expr.data.e_object.properties.len) : (i += 1) {
-                        const property: js_ast.G.Property = package_json_expr.data.e_object.properties.ptr[i];
+                        const property: js_ast.G.Property = package_json_expr.data.e_object.properties.ptr.?[i];
                         const key = property.key.?.asString(ctx.allocator).?;
 
                         if (strings.eqlComptime(key, "scripts")) {
@@ -1378,7 +1378,7 @@ pub const CreateCommand = struct {
                         }
 
                         if (key.len == 0 or !strings.eqlComptime(key, "bun-create")) {
-                            package_json_expr.data.e_object.properties.ptr[property_i] = property;
+                            package_json_expr.data.e_object.properties.ptr.?[property_i] = property;
                             property_i += 1;
                             continue;
                         }
@@ -1452,7 +1452,7 @@ pub const CreateCommand = struct {
                             }
                         }
                     }
-                    package_json_expr.data.e_object.properties = js_ast.G.Property.List.init(package_json_expr.data.e_object.properties.ptr[0..property_i]);
+                    package_json_expr.data.e_object.properties = js_ast.G.Property.List.init(package_json_expr.data.e_object.properties.ptr.?[0..property_i]);
                 }
 
                 var package_json_writer = JSPrinter.NewFileWriter(package_json_file.?);

src/install/lockfile.zig

@@ -3450,8 +3450,8 @@ pub const Package = extern struct {
                         switch (obj.properties.len) {
                             0 => {},
                             1 => {
-                                const bin_name = obj.properties.ptr[0].key.?.asString(allocator) orelse break :bin;
-                                const value = obj.properties.ptr[0].value.?.asString(allocator) orelse break :bin;
+                                const bin_name = obj.properties.ptr.?[0].key.?.asString(allocator) orelse break :bin;
+                                const value = obj.properties.ptr.?[0].value.?.asString(allocator) orelse break :bin;
 
                                 package.bin = .{
                                     .tag = .named_file,