@zigc/lib 0.16.0-test.0 → 0.16.0

package/compiler/aro/aro/TypeStore.zig

@@ -219,9 +219,9 @@ pub const QualType = packed struct(u32) {
             .float_dfloat64 => return .{ .float = .dfloat64 },
             .float_dfloat128 => return .{ .float = .dfloat128 },
             .float_dfloat64x => return .{ .float = .dfloat64x },
-            .void_pointer => return .{ .pointer = .{ .child = .void, .decayed = null } },
-            .char_pointer => return .{ .pointer = .{ .child = .char, .decayed = null } },
-            .int_pointer => return .{ .pointer = .{ .child = .int, .decayed = null } },
+            .void_pointer => return .{ .pointer = .{ .child = .void } },
+            .char_pointer => return .{ .pointer = .{ .child = .char } },
+            .int_pointer => return .{ .pointer = .{ .child = .int } },
 
             else => {},
         }
@@ -280,7 +280,7 @@ pub const QualType = packed struct(u32) {
             },
             .pointer => .{ .pointer = .{
                 .child = @bitCast(repr.data[0]),
-                .decayed = null,
+                .bounds = @enumFromInt(repr.data[1]),
             } },
             .pointer_decayed => .{ .pointer = .{
                 .child = @bitCast(repr.data[0]),
@@ -800,7 +800,6 @@ pub const QualType = packed struct(u32) {
 
                 return comp.type_store.put(comp.gpa, .{ .pointer = .{
                     .child = qt,
-                    .decayed = null,
                 } });
             },
             else => return qt,
@@ -1013,6 +1012,15 @@ pub const QualType = packed struct(u32) {
         return qt.scalarKind(comp).isPointer();
     }
 
+    /// Function or function pointer
+    pub fn isCallable(qt: QualType, comp: *const Compilation) bool {
+        return switch (qt.base(comp).type) {
+            .func => true,
+            .pointer => |ptr| ptr.child.is(comp, .func),
+            else => false,
+        };
+    }
+
     pub fn eqlQualified(a_qt: QualType, b_qt: QualType, comp: *const Compilation) bool {
         if (a_qt.@"const" != b_qt.@"const") return false;
         if (a_qt.@"volatile" != b_qt.@"volatile") return false;
@@ -1632,7 +1640,25 @@ pub const Type = union(enum) {
 
     pub const Pointer = struct {
         child: QualType,
-        decayed: ?QualType,
+        decayed: ?QualType = null,
+        bounds: Bounds = .c,
+
+        pub const Bounds = enum {
+            /// C pointer with no bounds attribute
+            c,
+            /// No pointer arithmetic or non-zero indexing
+            single,
+            /// Explicitly specified as a traditional C pointer
+            unsafe_indexable,
+
+            pub fn fromTag(tag: Attribute.Tag) Bounds {
+                return switch (tag) {
+                    .single => .single,
+                    .unsafe_indexable => .unsafe_indexable,
+                    else => unreachable,
+                };
+            }
+        };
     };
 
     pub const Array = struct {
@@ -1784,6 +1810,7 @@ attributes: std.ArrayList(Attribute) = .empty,
 anon_name_arena: std.heap.ArenaAllocator.State = .{},
 
 wchar: QualType = .invalid,
+wint: QualType = .invalid,
 uint_least16_t: QualType = .invalid,
 uint_least32_t: QualType = .invalid,
 ptrdiff: QualType = .invalid,
@@ -1918,10 +1945,12 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void
         .pointer => |pointer| {
             repr.data[0] = @bitCast(pointer.child);
             if (pointer.decayed) |array| {
+                std.debug.assert(pointer.bounds == .c);
                 repr.tag = .pointer_decayed;
                 repr.data[1] = @bitCast(array);
             } else {
                 repr.tag = .pointer;
+                repr.data[1] = @intFromEnum(pointer.bounds);
             }
         },
         .array => |array| {
@@ -2070,17 +2099,44 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void
 
 pub fn initNamedTypes(ts: *TypeStore, comp: *Compilation) !void {
     const os = comp.target.os.tag;
-    ts.wchar = switch (comp.target.cpu.arch) {
-        .xcore => .uchar,
-        .ve, .msp430 => .uint,
-        .arm, .armeb, .thumb, .thumbeb => if (os != .windows and os != .netbsd and os != .openbsd) .uint else .int,
-        .aarch64, .aarch64_be => if (!os.isDarwin() and os != .netbsd) .uint else .int,
-        .x86_64, .x86 => if (os == .windows) .ushort else .int,
-        else => .int,
+    const arch = comp.target.cpu.arch;
+    ts.wchar = switch (os) {
+        .openbsd, .netbsd => .int,
+        .ps4, .ps5 => .ushort,
+        .uefi => .ushort,
+        .windows => .ushort,
+        .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => .int,
+        else => switch (arch) {
+            .aarch64, .aarch64_be => .uint,
+            .arm, .armeb, .thumb, .thumbeb => .uint,
+            .ve, .msp430 => .uint,
+            .x86_64, .x86 => .int,
+            .xcore => .uchar,
+            else => .int,
+        },
+    };
+
+    ts.wint = switch (os) {
+        .fuchsia => .uint,
+        .linux => .uint,
+        .openbsd => .int,
+        .uefi => .ushort,
+        .windows => .ushort,
+        else => switch (arch) {
+            .csky => .uint,
+            .loongarch32, .loongarch64 => .uint,
+            .riscv32, .riscv32be, .riscv64, .riscv64be => .uint,
+            .ve => .uint,
+            .xcore => .uint,
+            .xtensa, .xtensaeb => .uint,
+            else => .int,
+        },
     };
 
     const ptr_width = comp.target.ptrBitWidth();
-    ts.ptrdiff = if (os == .windows and ptr_width == 64)
+    ts.ptrdiff = if (arch == .wasm32)
+        .long
+    else if (os == .windows and ptr_width == 64)
         .long_long
     else switch (ptr_width) {
         16 => .int,
@@ -2089,7 +2145,9 @@ pub fn initNamedTypes(ts: *TypeStore, comp: *Compilation) !void {
         else => unreachable,
     };
 
-    ts.size = if (os == .windows and ptr_width == 64)
+    ts.size = if (arch == .wasm32)
+        .ulong
+    else if (os == .windows and ptr_width == 64)
         .ulong_long
     else switch (ptr_width) {
         16 => .uint,
@@ -2206,9 +2264,9 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType {
     };
 
     const struct_qt = switch (kind) {
-        .aarch64_va_list => blk: {
+        .aarch64_va_list => {
             var record: Type.Record = .{
-                .name = try comp.internString("__va_list_tag"),
+                .name = try comp.internString("__va_list"),
                 .decl_node = undefined, // TODO
                 .layout = null,
                 .fields = &.{},
@@ -2226,11 +2284,11 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType {
             record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable;
             try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index));
 
-            break :blk qt;
+            return qt;
         },
-        .arm_va_list => blk: {
+        .arm_va_list => {
             var record: Type.Record = .{
-                .name = try comp.internString("__va_list_tag"),
+                .name = try comp.internString("__va_list"),
                 .decl_node = undefined, // TODO
                 .layout = null,
                 .fields = &.{},
@@ -2244,7 +2302,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType {
             record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable;
             try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index));
 
-            break :blk qt;
+            return qt;
         },
         .hexagon_va_list => blk: {
             var record: Type.Record = .{
@@ -2330,7 +2388,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType {
 
             break :blk qt;
         },
-        .xtensa_va_list => blk: {
+        .xtensa_va_list => {
             var record: Type.Record = .{
                 .name = try comp.internString("__va_list_tag"),
                 .decl_node = undefined, // TODO
@@ -2348,7 +2406,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType {
             record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable;
             try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index));
 
-            break :blk qt;
+            return qt;
         },
     };
 
@@ -2830,7 +2888,7 @@ pub const Builder = struct {
     }
 
     fn duplicateSpec(b: *Builder, source_tok: TokenIndex, spec: []const u8) !void {
-        if (b.parser.comp.langopts.emulate != .clang) return b.cannotCombine(source_tok);
+        if (b.parser.comp.langopts.emulate == .gcc) return b.cannotCombine(source_tok);
         try b.parser.err(b.parser.tok_i, .duplicate_decl_spec, .{spec});
     }
 

package/compiler/aro/aro/Value.zig

@@ -1,5 +1,4 @@
 const std = @import("std");
-const Io = std.Io;
 const assert = std.debug.assert;
 const BigIntConst = std.math.big.int.Const;
 const BigIntMutable = std.math.big.int.Mutable;
@@ -9,8 +8,8 @@ const BigIntSpace = Interner.Tag.Int.BigIntSpace;
 
 const annex_g = @import("annex_g.zig");
 const Compilation = @import("Compilation.zig");
-const Target = @import("Target.zig");
 const QualType = @import("TypeStore.zig").QualType;
+const Target = @import("Target.zig");
 
 const Value = @This();
 
@@ -77,11 +76,7 @@ test "minUnsignedBits" {
         }
     };
 
-    var arena_state: std.heap.ArenaAllocator = .init(std.testing.allocator);
-    defer arena_state.deinit();
-    const arena = arena_state.allocator();
-
-    var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, undefined, Io.Dir.cwd());
+    var comp = try Compilation.init(.testing);
     defer comp.deinit();
     const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });
     comp.target = .fromZigTarget(try std.zig.system.resolveTargetQuery(std.testing.io, target_query));
@@ -116,11 +111,7 @@ test "minSignedBits" {
         }
     };
 
-    var arena_state: std.heap.ArenaAllocator = .init(std.testing.allocator);
-    defer arena_state.deinit();
-    const arena = arena_state.allocator();
-
-    var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, undefined, Io.Dir.cwd());
+    var comp = try Compilation.init(.testing);
     defer comp.deinit();
     const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });
     comp.target = .fromZigTarget(try std.zig.system.resolveTargetQuery(std.testing.io, target_query));
@@ -465,6 +456,11 @@ pub fn isNan(v: Value, comp: *const Compilation) bool {
     };
 }
 
+pub fn isPointer(v: Value, comp: *const Compilation) bool {
+    if (v.opt_ref == .none) return false;
+    return comp.interner.get(v.ref()) == .pointer;
+}
+
 /// Converts value to zero or one;
 /// `.none` value remains unchanged.
 pub fn boolCast(v: *Value, comp: *const Compilation) void {
@@ -1044,9 +1040,9 @@ fn twosCompIntLimit(limit: std.math.big.int.TwosCompIntLimit, qt: QualType, comp
     const mag_bits: usize = @intCast(qt.bitSizeof(comp));
     switch (mag_bits) {
         inline 8, 16, 32, 64 => |bits| {
-            if (limit == .min) return Value.int(@as(i64, std.math.minInt(std.meta.Int(.signed, bits))), comp);
+            if (limit == .min) return Value.int(@as(i64, std.math.minInt(@Int(.signed, bits))), comp);
             return switch (signedness) {
-                inline else => |sign| Value.int(std.math.maxInt(std.meta.Int(sign, bits)), comp),
+                inline else => |sign| Value.int(std.math.maxInt(@Int(sign, bits)), comp),
             };
         },
         else => {},
@@ -1081,7 +1077,7 @@ const NestedPrint = union(enum) {
     },
 };
 
-pub fn printPointer(offset: Value, base: []const u8, comp: *const Compilation, w: *Io.Writer) Io.Writer.Error!void {
+pub fn printPointer(offset: Value, base: []const u8, comp: *const Compilation, w: *std.Io.Writer) std.Io.Writer.Error!void {
     try w.writeByte('&');
     try w.writeAll(base);
     if (!offset.isZero(comp)) {
@@ -1090,7 +1086,7 @@ pub fn printPointer(offset: Value, base: []const u8, comp: *const Compilation, w
     }
 }
 
-pub fn print(v: Value, qt: QualType, comp: *const Compilation, w: *Io.Writer) Io.Writer.Error!?NestedPrint {
+pub fn print(v: Value, qt: QualType, comp: *const Compilation, w: *std.Io.Writer) std.Io.Writer.Error!?NestedPrint {
     if (qt.is(comp, .bool)) {
         try w.writeAll(if (v.isZero(comp)) "false" else "true");
         return null;
@@ -1117,7 +1113,7 @@ pub fn print(v: Value, qt: QualType, comp: *const Compilation, w: *Io.Writer) Io
     return null;
 }
 
-pub fn printString(bytes: []const u8, qt: QualType, comp: *const Compilation, w: *Io.Writer) Io.Writer.Error!void {
+pub fn printString(bytes: []const u8, qt: QualType, comp: *const Compilation, w: *std.Io.Writer) std.Io.Writer.Error!void {
     const size: Compilation.CharUnitSize = @enumFromInt(qt.childType(comp).sizeof(comp));
     const without_null = bytes[0 .. bytes.len - @intFromEnum(size)];
     try w.writeByte('"');

package/compiler/aro/aro/features.zig

@@ -44,6 +44,7 @@ pub fn hasFeature(comp: *Compilation, ext: []const u8) bool {
         .c_generic_selections = comp.langopts.standard.atLeast(.c11),
         .c_static_assert = comp.langopts.standard.atLeast(.c11),
         .c_thread_local = comp.langopts.standard.atLeast(.c11) and comp.target.isTlsSupported(),
+        .bounds_attributes = comp.langopts.bounds_safety == .clang,
     };
     inline for (@typeInfo(@TypeOf(list)).@"struct".fields) |f| {
         if (std.mem.eql(u8, f.name, ext)) return @field(list, f.name);

package/compiler/aro/aro/pragmas/once.zig

@@ -35,7 +35,6 @@ fn deinit(pragma: *Pragma, comp: *Compilation) void {
     var self: *Once = @fieldParentPtr("pragma", pragma);
     self.pragma_once.deinit(comp.gpa);
     comp.gpa.destroy(self);
-    pragma.* = undefined;
 }
 
 fn preprocessorHandler(pragma: *Pragma, pp: *Preprocessor, start_idx: TokenIndex) Pragma.Error!void {

package/compiler/aro/aro/record_layout.zig

@@ -332,7 +332,7 @@ const SysVContext = struct {
                 }
             }
         } else {
-            std.debug.assert(self.comp.langopts.emulate == .clang);
+            std.debug.assert(self.comp.langopts.emulate == .no or self.comp.langopts.emulate == .clang);
 
             // On Clang, the alignment requested by annotations is not respected if it is
             // larger than the value of #pragma pack. See test case 0083.
@@ -569,7 +569,7 @@ const MsvcContext = struct {
 
 pub fn compute(fields: []Type.Record.Field, qt: QualType, comp: *const Compilation, pragma_pack: ?u8) Error!Type.Record.Layout {
     switch (comp.langopts.emulate) {
-        .gcc, .clang => {
+        .no, .gcc, .clang => {
             var context = SysVContext.init(qt, comp, pragma_pack);
 
             try context.layoutFields(fields);
@@ -620,7 +620,7 @@ fn computeLayout(qt: QualType, comp: *const Compilation) RecordLayout {
         else => {
             const type_align = qt.alignof(comp) * BITS_PER_BYTE;
             return .{
-                .size_bits = qt.bitSizeofOrNull(comp) orelse 0,
+                .size_bits = BITS_PER_BYTE * (qt.sizeofOrNull(comp) orelse 0),
                 .pointer_alignment_bits = type_align,
                 .field_alignment_bits = type_align,
                 .required_alignment_bits = BITS_PER_BYTE,

package/compiler/aro/assembly_backend/x86_64.zig

@@ -5,15 +5,14 @@ const assert = std.debug.assert;
 const aro = @import("aro");
 const Assembly = aro.Assembly;
 const Compilation = aro.Compilation;
-const Node = Tree.Node;
 const Source = aro.Source;
 const Tree = aro.Tree;
 const QualType = aro.QualType;
 const Value = aro.Value;
-
-const AsmCodeGen = @This();
 const Error = aro.Compilation.Error;
+const Node = Tree.Node;
 
+const AsmCodeGen = @This();
 tree: *const Tree,
 comp: *Compilation,
 text: *std.Io.Writer,
@@ -58,7 +57,7 @@ fn serializeFloat(comptime T: type, value: T, w: *std.Io.Writer) !void {
         },
         else => {
             const size = @bitSizeOf(T);
-            const storage_unit = std.enums.fromInt(StorageUnit, size).?;
+            const storage_unit = std.enums.fromInt(StorageUnit, size) orelse unreachable;
             const IntTy = @Int(.unsigned, size);
             const int_val: IntTy = @bitCast(value);
             return serializeInt(int_val, storage_unit, w);

package/compiler/aro/backend/Assembly.zig

@@ -1,5 +1,4 @@
 const std = @import("std");
-const Io = std.Io;
 const Allocator = std.mem.Allocator;
 
 data: []const u8,
@@ -12,7 +11,7 @@ pub fn deinit(self: *const Assembly, gpa: Allocator) void {
     gpa.free(self.text);
 }
 
-pub fn writeToFile(self: Assembly, io: Io, file: Io.File) !void {
+pub fn writeToFile(self: Assembly, io: std.Io, file: std.Io.File) !void {
     var file_writer = file.writer(io, &.{});
 
     var buffers = [_][]const u8{ self.data, self.text };

package/compiler/aro/backend/Interner.zig

@@ -102,13 +102,13 @@ pub const Key = union(enum) {
             .float => |repr| switch (repr) {
                 inline else => |data| std.hash.autoHash(
                     &hasher,
-                    @as(std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),
+                    @as(@Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),
                 ),
             },
             .complex => |repr| switch (repr) {
                 inline else => |data| std.hash.autoHash(
                     &hasher,
-                    @as(std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),
+                    @as(@Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),
                 ),
             },
             .int => |repr| {