motiejus/zig
1
Fork 0
Code Releases Activity

cbe: fix optional codegen

Browse Source 
Also reduce ctype pool string memory usage, remove self assignments, and
enable more warnings.
This commit is contained in:
Jacob Young
2024-04-11 23:40:15 -04:00
parent 05d9755766
commit f1c0f42cdd
17 changed files with 1118 additions and 850 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1527
src/codegen/c.zig
View File

File diff suppressed because it is too large Load Diff

328
src/codegen/c/Type.zig
View File

@@ -1,13 +1,33 @@
index: CType.Index,
pub const @"void": CType = .{ .index = .void };
pub const @"bool": CType = .{ .index = .bool };
pub const @"i8": CType = .{ .index = .int8_t };
pub const @"u8": CType = .{ .index = .uint8_t };
pub const @"i16": CType = .{ .index = .int16_t };
pub const @"u16": CType = .{ .index = .uint16_t };
pub const @"i32": CType = .{ .index = .int32_t };
pub const @"u32": CType = .{ .index = .uint32_t };
pub const @"i64": CType = .{ .index = .int64_t };
pub const @"u64": CType = .{ .index = .uint64_t };
pub const @"i128": CType = .{ .index = .zig_i128 };
pub const @"u128": CType = .{ .index = .zig_u128 };
pub const @"isize": CType = .{ .index = .intptr_t };
pub const @"usize": CType = .{ .index = .uintptr_t };
pub const @"f16": CType = .{ .index = .zig_f16 };
pub const @"f32": CType = .{ .index = .zig_f32 };
pub const @"f64": CType = .{ .index = .zig_f64 };
pub const @"f80": CType = .{ .index = .zig_f80 };
pub const @"f128": CType = .{ .index = .zig_f128 };
pub fn fromPoolIndex(pool_index: usize) CType {
return .{ .index = @enumFromInt(CType.Index.first_pool_index + pool_index) };
}
pub fn toPoolIndex(ctype: CType) ?u32 {
const pool_index, const is_basic =
const pool_index, const is_null =
@subWithOverflow(@intFromEnum(ctype.index), CType.Index.first_pool_index);
return switch (is_basic) {
return switch (is_null) {
0 => pool_index,
1 => null,
};
@@ -710,20 +730,6 @@ pub const Kind = enum {
}
};
pub const String = struct {
index: String.Index,
const Index = enum(u32) {
_,
};
pub fn slice(string: String, pool: *const Pool) []const u8 {
const start = pool.string_indices.items[@intFromEnum(string.index)];
const end = pool.string_indices.items[@intFromEnum(string.index) + 1];
return pool.string_bytes.items[start..end];
}
};
pub const Info = union(enum) {
basic: CType.Index,
pointer: Pointer,
@@ -766,7 +772,7 @@ pub const Info = union(enum) {
pub const AggregateTag = enum { @"enum", @"struct", @"union" };
pub const Field = struct {
name: String,
name: Pool.String,
ctype: CType,
alignas: AlignAs,
@@ -812,12 +818,15 @@ pub const Info = union(enum) {
rhs_pool: *const Pool,
pool_adapter: anytype,
) bool {
return std.meta.eql(lhs_field.alignas, rhs_field.alignas) and
pool_adapter.eql(lhs_field.ctype, rhs_field.ctype) and std.mem.eql(
u8,
lhs_field.name.slice(lhs_pool),
rhs_field.name.slice(rhs_pool),
);
if (!std.meta.eql(lhs_field.alignas, rhs_field.alignas)) return false;
if (!pool_adapter.eql(lhs_field.ctype, rhs_field.ctype)) return false;
return if (lhs_field.name.toPoolSlice(lhs_pool)) |lhs_name|
if (rhs_field.name.toPoolSlice(rhs_pool)) |rhs_name|
std.mem.eql(u8, lhs_name, rhs_name)
else
false
else
lhs_field.name.index == rhs_field.name.index;
}
};
@@ -918,6 +927,86 @@ pub const Pool = struct {
const Map = std.AutoArrayHashMapUnmanaged(void, void);
pub const String = struct {
index: String.Index,
const FormatData = struct { string: String, pool: *const Pool };
fn format(
data: FormatData,
comptime fmt_str: []const u8,
_: std.fmt.FormatOptions,
writer: anytype,
) @TypeOf(writer).Error!void {
if (fmt_str.len > 0) @compileError("invalid format string '" ++ fmt_str ++ "'");
if (data.string.toSlice(data.pool)) |slice|
try writer.writeAll(slice)
else
try writer.print("f{d}", .{@intFromEnum(data.string.index)});
}
pub fn fmt(str: String, pool: *const Pool) std.fmt.Formatter(format) {
return .{ .data = .{ .string = str, .pool = pool } };
}
fn fromUnnamed(index: u31) String {
return .{ .index = @enumFromInt(index) };
}
fn isNamed(str: String) bool {
return @intFromEnum(str.index) >= String.Index.first_named_index;
}
pub fn toSlice(str: String, pool: *const Pool) ?[]const u8 {
return str.toPoolSlice(pool) orelse if (str.isNamed()) @tagName(str.index) else null;
}
fn toPoolSlice(str: String, pool: *const Pool) ?[]const u8 {
if (str.toPoolIndex()) |pool_index| {
const start = pool.string_indices.items[pool_index + 0];
const end = pool.string_indices.items[pool_index + 1];
return pool.string_bytes.items[start..end];
} else return null;
}
fn fromPoolIndex(pool_index: usize) String {
return .{ .index = @enumFromInt(String.Index.first_pool_index + pool_index) };
}
fn toPoolIndex(str: String) ?u32 {
const pool_index, const is_null =
@subWithOverflow(@intFromEnum(str.index), String.Index.first_pool_index);
return switch (is_null) {
0 => pool_index,
1 => null,
};
}
const Index = enum(u32) {
array = first_named_index,
@"error",
is_null,
len,
payload,
ptr,
tag,
_,
const first_named_index: u32 = 1 << 31;
const first_pool_index: u32 = first_named_index + @typeInfo(String.Index).Enum.fields.len;
};
const Adapter = struct {
pool: *const Pool,
pub fn hash(_: @This(), slice: []const u8) Map.Hash {
return @truncate(Hasher.Impl.hash(1, slice));
}
pub fn eql(string_adapter: @This(), lhs_slice: []const u8, _: void, rhs_index: usize) bool {
const rhs_string = String.fromPoolIndex(rhs_index);
const rhs_slice = rhs_string.toPoolSlice(string_adapter.pool).?;
return std.mem.eql(u8, lhs_slice, rhs_slice);
}
};
};
pub const empty: Pool = .{
.map = .{},
.items = .{},
@@ -1200,26 +1289,26 @@ pub const Pool = struct {
kind: Kind,
) !CType {
switch (int_info.bits) {
0 => return .{ .index = .void },
0 => return CType.void,
1...8 => switch (int_info.signedness) {
.unsigned => return .{ .index = .uint8_t },
.signed => return .{ .index = .int8_t },
.signed => return CType.i8,
.unsigned => return CType.u8,
},
9...16 => switch (int_info.signedness) {
.unsigned => return .{ .index = .uint16_t },
.signed => return .{ .index = .int16_t },
.signed => return CType.i16,
.unsigned => return CType.u16,
},
17...32 => switch (int_info.signedness) {
.unsigned => return .{ .index = .uint32_t },
.signed => return .{ .index = .int32_t },
.signed => return CType.i32,
.unsigned => return CType.u32,
},
33...64 => switch (int_info.signedness) {
.unsigned => return .{ .index = .uint64_t },
.signed => return .{ .index = .int64_t },
.signed => return CType.i64,
.unsigned => return CType.u64,
},
65...128 => switch (int_info.signedness) {
.unsigned => return .{ .index = .zig_u128 },
.signed => return .{ .index = .zig_i128 },
.signed => return CType.i128,
.unsigned => return CType.u128,
},
else => {
const target = &mod.resolved_target.result;
@@ -1235,7 +1324,7 @@ pub const Pool = struct {
if (!kind.isParameter()) return array_ctype;
var fields = [_]Info.Field{
.{
.name = try pool.string(allocator, "array"),
.name = .{ .index = .array },
.ctype = array_ctype,
.alignas = AlignAs.fromAbiAlignment(abi_align),
},
@@ -1267,19 +1356,19 @@ pub const Pool = struct {
.null_type,
.undefined_type,
.enum_literal_type,
=> return .{ .index = .void },
.u1_type, .u8_type => return .{ .index = .uint8_t },
.i8_type => return .{ .index = .int8_t },
.u16_type => return .{ .index = .uint16_t },
.i16_type => return .{ .index = .int16_t },
.u29_type, .u32_type => return .{ .index = .uint32_t },
.i32_type => return .{ .index = .int32_t },
.u64_type => return .{ .index = .uint64_t },
.i64_type => return .{ .index = .int64_t },
.u80_type, .u128_type => return .{ .index = .zig_u128 },
.i128_type => return .{ .index = .zig_i128 },
.usize_type => return .{ .index = .uintptr_t },
.isize_type => return .{ .index = .intptr_t },
=> return CType.void,
.u1_type, .u8_type => return CType.u8,
.i8_type => return CType.i8,
.u16_type => return CType.u16,
.i16_type => return CType.i16,
.u29_type, .u32_type => return CType.u32,
.i32_type => return CType.i32,
.u64_type => return CType.u64,
.i64_type => return CType.i64,
.u80_type, .u128_type => return CType.u128,
.i128_type => return CType.i128,
.usize_type => return CType.usize,
.isize_type => return CType.isize,
.c_char_type => return .{ .index = .char },
.c_short_type => return .{ .index = .short },
.c_ushort_type => return .{ .index = .@"unsigned short" },
@@ -1290,12 +1379,12 @@ pub const Pool = struct {
.c_longlong_type => return .{ .index = .@"long long" },
.c_ulonglong_type => return .{ .index = .@"unsigned long long" },
.c_longdouble_type => return .{ .index = .@"long double" },
.f16_type => return .{ .index = .zig_f16 },
.f32_type => return .{ .index = .zig_f32 },
.f64_type => return .{ .index = .zig_f64 },
.f80_type => return .{ .index = .zig_f80 },
.f128_type => return .{ .index = .zig_f128 },
.bool_type, .optional_noreturn_type => return .{ .index = .bool },
.f16_type => return CType.f16,
.f32_type => return CType.f32,
.f64_type => return CType.f64,
.f80_type => return CType.f80,
.f128_type => return CType.f128,
.bool_type, .optional_noreturn_type => return CType.bool,
.noreturn_type,
.anyframe_type,
.generic_poison_type,
@@ -1324,17 +1413,17 @@ pub const Pool = struct {
}, mod, kind),
.manyptr_u8_type,
=> return pool.getPointer(allocator, .{
.elem_ctype = .{ .index = .uint8_t },
.elem_ctype = CType.u8,
}),
.manyptr_const_u8_type,
.manyptr_const_u8_sentinel_0_type,
=> return pool.getPointer(allocator, .{
.elem_ctype = .{ .index = .uint8_t },
.elem_ctype = CType.u8,
.@"const" = true,
}),
.single_const_pointer_to_comptime_int_type,
=> return pool.getPointer(allocator, .{
.elem_ctype = .{ .index = .void },
.elem_ctype = CType.void,
.@"const" = true,
}),
.slice_const_u8_type,
@@ -1343,16 +1432,16 @@ pub const Pool = struct {
const target = &mod.resolved_target.result;
var fields = [_]Info.Field{
.{
.name = try pool.string(allocator, "ptr"),
.name = .{ .index = .ptr },
.ctype = try pool.getPointer(allocator, .{
.elem_ctype = .{ .index = .uint8_t },
.elem_ctype = CType.u8,
.@"const" = true,
}),
.alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target.*)),
},
.{
.name = try pool.string(allocator, "len"),
.ctype = .{ .index = .uintptr_t },
.name = .{ .index = .len },
.ctype = CType.usize,
.alignas = AlignAs.fromAbiAlignment(
Type.intAbiAlignment(target.ptrBitWidth(), target.*),
),
@@ -1442,7 +1531,7 @@ pub const Pool = struct {
const target = &mod.resolved_target.result;
var fields = [_]Info.Field{
.{
.name = try pool.string(allocator, "ptr"),
.name = .{ .index = .ptr },
.ctype = try pool.fromType(
allocator,
scratch,
@@ -1454,8 +1543,8 @@ pub const Pool = struct {
.alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target.*)),
},
.{
.name = try pool.string(allocator, "len"),
.ctype = .{ .index = .uintptr_t },
.name = .{ .index = .len },
.ctype = CType.usize,
.alignas = AlignAs.fromAbiAlignment(
Type.intAbiAlignment(target.ptrBitWidth(), target.*),
),
@@ -1466,7 +1555,7 @@ pub const Pool = struct {
},
.array_type => |array_info| {
const len = array_info.lenIncludingSentinel();
if (len == 0) return .{ .index = .void };
if (len == 0) return CType.void;
const elem_type = Type.fromInterned(array_info.child);
const elem_ctype = try pool.fromType(
allocator,
@@ -1476,7 +1565,7 @@ pub const Pool = struct {
mod,
kind.noParameter(),
);
if (elem_ctype.index == .void) return .{ .index = .void };
if (elem_ctype.index == .void) return CType.void;
const array_ctype = try pool.getArray(allocator, .{
.elem_ctype = elem_ctype,
.len = len,
@@ -1484,7 +1573,7 @@ pub const Pool = struct {
if (!kind.isParameter()) return array_ctype;
var fields = [_]Info.Field{
.{
.name = try pool.string(allocator, "array"),
.name = .{ .index = .array },
.ctype = array_ctype,
.alignas = AlignAs.fromAbiAlignment(elem_type.abiAlignment(zcu)),
},
@@ -1492,7 +1581,7 @@ pub const Pool = struct {
return pool.fromFields(allocator, .@"struct", &fields, kind);
},
.vector_type => |vector_info| {
if (vector_info.len == 0) return .{ .index = .void };
if (vector_info.len == 0) return CType.void;
const elem_type = Type.fromInterned(vector_info.child);
const elem_ctype = try pool.fromType(
allocator,
@@ -1502,7 +1591,7 @@ pub const Pool = struct {
mod,
kind.noParameter(),
);
if (elem_ctype.index == .void) return .{ .index = .void };
if (elem_ctype.index == .void) return CType.void;
const vector_ctype = try pool.getVector(allocator, .{
.elem_ctype = elem_ctype,
.len = vector_info.len,
@@ -1510,7 +1599,7 @@ pub const Pool = struct {
if (!kind.isParameter()) return vector_ctype;
var fields = [_]Info.Field{
.{
.name = try pool.string(allocator, "array"),
.name = .{ .index = .array },
.ctype = vector_ctype,
.alignas = AlignAs.fromAbiAlignment(elem_type.abiAlignment(zcu)),
},
@@ -1518,7 +1607,7 @@ pub const Pool = struct {
return pool.fromFields(allocator, .@"struct", &fields, kind);
},
.opt_type => |payload_type| {
if (ip.isNoReturn(payload_type)) return .{ .index = .void };
if (ip.isNoReturn(payload_type)) return CType.void;
const payload_ctype = try pool.fromType(
allocator,
scratch,
@@ -1527,7 +1616,7 @@ pub const Pool = struct {
mod,
kind.noParameter(),
);
if (payload_ctype.index == .void) return .{ .index = .bool };
if (payload_ctype.index == .void) return CType.bool;
switch (payload_type) {
.anyerror_type => return payload_ctype,
else => switch (ip.indexToKey(payload_type)) {
@@ -1539,12 +1628,12 @@ pub const Pool = struct {
}
var fields = [_]Info.Field{
.{
.name = try pool.string(allocator, "is_null"),
.ctype = .{ .index = .bool },
.name = .{ .index = .is_null },
.ctype = CType.bool,
.alignas = AlignAs.fromAbiAlignment(.@"1"),
},
.{
.name = try pool.string(allocator, "payload"),
.name = .{ .index = .payload },
.ctype = payload_ctype,
.alignas = AlignAs.fromAbiAlignment(
Type.fromInterned(payload_type).abiAlignment(zcu),
@@ -1574,14 +1663,14 @@ pub const Pool = struct {
const target = &mod.resolved_target.result;
var fields = [_]Info.Field{
.{
.name = try pool.string(allocator, "error"),
.name = .{ .index = .@"error" },
.ctype = error_set_ctype,
.alignas = AlignAs.fromAbiAlignment(
Type.intAbiAlignment(error_set_bits, target.*),
),
},
.{
.name = try pool.string(allocator, "payload"),
.name = .{ .index = .payload },
.ctype = payload_ctype,
.alignas = AlignAs.fromAbiAlignment(payload_type.abiAlignment(zcu)),
},
@@ -1600,7 +1689,7 @@ pub const Pool = struct {
if (kind.isForward()) return if (ty.hasRuntimeBitsIgnoreComptime(zcu))
fwd_decl
else
.{ .index = .void };
CType.void;
const scratch_top = scratch.items.len;
defer scratch.shrinkRetainingCapacity(scratch_top);
try scratch.ensureUnusedCapacity(
@@ -1627,7 +1716,7 @@ pub const Pool = struct {
.unwrap()) |field_name|
try pool.string(allocator, field_name.toSlice(ip))
else
try pool.fmt(allocator, "f{d}", .{field_index});
String.fromUnnamed(@intCast(field_index));
const field_alignas = AlignAs.fromAlignment(.{
.@"align" = loaded_struct.fieldAlign(ip, field_index),
.abi = field_type.abiAlignment(zcu),
@@ -1644,7 +1733,7 @@ pub const Pool = struct {
scratch.items.len - scratch_top,
@typeInfo(Field).Struct.fields.len,
));
if (fields_len == 0) return .{ .index = .void };
if (fields_len == 0) return CType.void;
try pool.ensureUnusedCapacity(allocator, 1);
const extra_index = try pool.addHashedExtra(allocator, &hasher, Aggregate, .{
.fwd_decl = fwd_decl.index,
@@ -1700,7 +1789,7 @@ pub const Pool = struct {
scratch.items.len - scratch_top,
@typeInfo(Field).Struct.fields.len,
));
if (fields_len == 0) return .{ .index = .void };
if (fields_len == 0) return CType.void;
if (kind.isForward()) {
try pool.ensureUnusedCapacity(allocator, 1);
const extra_index = try pool.addHashedExtra(
@@ -1739,7 +1828,7 @@ pub const Pool = struct {
if (kind.isForward()) return if (ty.hasRuntimeBitsIgnoreComptime(zcu))
fwd_decl
else
.{ .index = .void };
CType.void;
const loaded_tag = loaded_union.loadTagType(ip);
const scratch_top = scratch.items.len;
defer scratch.shrinkRetainingCapacity(scratch_top);
@@ -1786,7 +1875,7 @@ pub const Pool = struct {
@typeInfo(Field).Struct.fields.len,
));
if (!has_tag) {
if (fields_len == 0) return .{ .index = .void };
if (fields_len == 0) return CType.void;
try pool.ensureUnusedCapacity(allocator, 1);
const extra_index = try pool.addHashedExtra(
allocator,
@@ -1813,7 +1902,7 @@ pub const Pool = struct {
);
if (tag_ctype.index != .void) {
struct_fields[struct_fields_len] = .{
.name = try pool.string(allocator, "tag"),
.name = .{ .index = .tag },
.ctype = tag_ctype,
.alignas = AlignAs.fromAbiAlignment(tag_type.abiAlignment(zcu)),
};
@@ -1846,14 +1935,14 @@ pub const Pool = struct {
};
if (payload_ctype.index != .void) {
struct_fields[struct_fields_len] = .{
.name = try pool.string(allocator, "payload"),
.name = .{ .index = .payload },
.ctype = payload_ctype,
.alignas = AlignAs.fromAbiAlignment(payload_align),
};
struct_fields_len += 1;
}
}
if (struct_fields_len == 0) return .{ .index = .void };
if (struct_fields_len == 0) return CType.void;
sortFields(struct_fields[0..struct_fields_len]);
return pool.getAggregate(allocator, .{
.tag = .@"struct",
@@ -1867,7 +1956,7 @@ pub const Pool = struct {
}, mod, kind),
}
},
.opaque_type => return .{ .index = .void },
.opaque_type => return CType.void,
.enum_type => return pool.fromType(
allocator,
scratch,
@@ -1876,7 +1965,7 @@ pub const Pool = struct {
mod,
kind,
),
.func_type => |func_info| if (func_info.is_generic) return .{ .index = .void } else {
.func_type => |func_info| if (func_info.is_generic) return CType.void else {
const scratch_top = scratch.items.len;
defer scratch.shrinkRetainingCapacity(scratch_top);
try scratch.ensureUnusedCapacity(allocator, func_info.param_types.len);
@@ -1890,7 +1979,7 @@ pub const Pool = struct {
zcu,
mod,
kind.asParameter(),
) else .{ .index = .void };
) else CType.void;
for (0..func_info.param_types.len) |param_index| {
const param_type = Type.fromInterned(
func_info.param_types.get(ip)[param_index],
@@ -2024,7 +2113,10 @@ pub const Pool = struct {
});
for (0..fields.len) |field_index| {
const field = fields.at(field_index, source_pool);
const field_name = try pool.string(allocator, field.name.slice(source_pool));
const field_name = if (field.name.toPoolSlice(source_pool)) |slice|
try pool.string(allocator, slice)
else
field.name;
pool.addExtraAssumeCapacity(Field, .{
.name = field_name.index,
.ctype = pool_adapter.copy(field.ctype).index,
@@ -2054,7 +2146,10 @@ pub const Pool = struct {
});
for (0..aggregate_info.fields.len) |field_index| {
const field = aggregate_info.fields.at(field_index, source_pool);
const field_name = try pool.string(allocator, field.name.slice(source_pool));
const field_name = if (field.name.toPoolSlice(source_pool)) |slice|
try pool.string(allocator, slice)
else
field.name;
pool.addExtraAssumeCapacity(Field, .{
.name = field_name.index,
.ctype = pool_adapter.copy(field.ctype).index,
@@ -2082,8 +2177,8 @@ pub const Pool = struct {
return .{ ctype, gop.found_existing };
}
pub fn string(pool: *Pool, allocator: std.mem.Allocator, str: []const u8) !String {
try pool.string_bytes.appendSlice(allocator, str);
pub fn string(pool: *Pool, allocator: std.mem.Allocator, slice: []const u8) !String {
try pool.string_bytes.appendSlice(allocator, slice);
return pool.trailingString(allocator);
}
@@ -2111,12 +2206,15 @@ pub const Pool = struct {
fn updateExtra(hasher: *Hasher, comptime Extra: type, extra: Extra, pool: *const Pool) void {
inline for (@typeInfo(Extra).Struct.fields) |field| {
const value = @field(extra, field.name);
hasher.update(switch (field.type) {
switch (field.type) {
Pool.Tag, String, CType => unreachable,
CType.Index => (CType{ .index = value }).hash(pool),
String.Index => (String{ .index = value }).slice(pool),
else => value,
});
CType.Index => hasher.update((CType{ .index = value }).hash(pool)),
String.Index => if ((String{ .index = value }).toPoolSlice(pool)) |slice|
hasher.update(slice)
else
hasher.update(@intFromEnum(value)),
else => hasher.update(value),
}
}
}
fn update(hasher: *Hasher, data: anytype) void {
@@ -2231,30 +2329,30 @@ pub const Pool = struct {
}
fn trailingString(pool: *Pool, allocator: std.mem.Allocator) !String {
const StringAdapter = struct {
pool: *const Pool,
pub fn hash(_: @This(), slice: []const u8) Map.Hash {
return @truncate(Hasher.Impl.hash(1, slice));
}
pub fn eql(string_adapter: @This(), lhs_slice: []const u8, _: void, rhs_index: usize) bool {
const rhs_string: String = .{ .index = @enumFromInt(rhs_index) };
const rhs_slice = rhs_string.slice(string_adapter.pool);
return std.mem.eql(u8, lhs_slice, rhs_slice);
}
};
const start = pool.string_indices.getLast();
const slice: []const u8 = pool.string_bytes.items[start..];
if (slice.len >= 2 and slice[0] == 'f' and switch (slice[1]) {
'0' => slice.len == 2,
'1'...'9' => true,
else => false,
}) if (std.fmt.parseInt(u31, slice[1..], 10)) |unnamed| {
pool.string_bytes.shrinkRetainingCapacity(start);
return String.fromUnnamed(unnamed);
} else |_| {};
if (std.meta.stringToEnum(String.Index, slice)) |index| {
pool.string_bytes.shrinkRetainingCapacity(start);
return .{ .index = index };
}
try pool.string_map.ensureUnusedCapacity(allocator, 1);
try pool.string_indices.ensureUnusedCapacity(allocator, 1);
const start = pool.string_indices.getLast();
const gop = pool.string_map.getOrPutAssumeCapacityAdapted(
@as([]const u8, pool.string_bytes.items[start..]),
StringAdapter{ .pool = pool },
);
const gop = pool.string_map.getOrPutAssumeCapacityAdapted(slice, String.Adapter{ .pool = pool });
if (gop.found_existing)
pool.string_bytes.shrinkRetainingCapacity(start)
else
pool.string_indices.appendAssumeCapacity(@intCast(pool.string_bytes.items.len));
return .{ .index = @enumFromInt(gop.index) };
return String.fromPoolIndex(gop.index);
}
const Item = struct {