tiny.choir.ir.interfaces

1pub const AbstractAttribute = struct {2    attr_id: u32,34    name: []const u8,56    interfaces: []const InterfaceEntry,78    pub fn getInterface(self: *const AbstractAttribute, id: InterfaceId) ?*const anyopaque {9        for (self.interfaces) |entry| {10            if (entry.id == id) return entry.vtable;11        }12        return null;13    }1415    pub fn hasInterface(self: *const AbstractAttribute, id: InterfaceId) bool {16        return self.getInterface(id) != null;17    }18};

1pub const AttributeRegistry = struct {2    allocator: std.mem.Allocator,3    attrs: std.StringHashMapUnmanaged(AttributeRegistryEntry),4    next_attr_id: u32,56    pub const AttributeRegistryEntry = struct {7        abstract: *const AbstractAttribute,8        owns_interfaces: bool,9    };1011    pub const RegisterError = error{DuplicateAttribute} || std.mem.Allocator.Error;1213    pub const RegisterInterfaceError = error{ UnknownAttribute, DuplicateInterface } || std.mem.Allocator.Error;1415    pub const RegisterOrReplaceInterfaceError = error{UnknownAttribute} || std.mem.Allocator.Error;1617    fn interfaceLessThan(_: void, a: InterfaceEntry, b: InterfaceEntry) bool {18        return a.id < b.id;19    }2021    pub fn init(allocator: std.mem.Allocator, first_dynamic_id: u32) AttributeRegistry {22        return .{23            .allocator = allocator,24            .attrs = .{},25            .next_attr_id = first_dynamic_id,26        };27    }2829    pub fn deinit(self: *AttributeRegistry) void {30        var it = self.attrs.valueIterator();31        while (it.next()) |entry| {32            const abstract = entry.abstract;33            if (entry.owns_interfaces and abstract.interfaces.len > 0) {34                self.allocator.free(@constCast(abstract.interfaces));35            }36            self.allocator.destroy(@constCast(abstract));37        }3839        var key_iter = self.attrs.keyIterator();40        while (key_iter.next()) |name_ptr| {41            self.allocator.free(name_ptr.*);42        }43        self.attrs.deinit(self.allocator);44    }4546    pub fn lookup(self: *const AttributeRegistry, attr_name: []const u8) ?*const AbstractAttribute {47        if (self.attrs.get(attr_name)) |entry| {48            return entry.abstract;49        }50        return null;51    }5253    pub fn nextAttributeId(self: *AttributeRegistry) u32 {54        return self.next_attr_id;55    }5657    pub fn restoreNextAttributeId(self: *AttributeRegistry, id: u32) void {58        self.next_attr_id = id;59    }6061    pub fn registerAttribute(62        self: *AttributeRegistry,63        attr_name: []const u8,64        interfaces: []const InterfaceEntry,65    ) RegisterError!*const AbstractAttribute {66        if (self.attrs.get(attr_name) != null) return error.DuplicateAttribute;6768        const owned_name = try self.allocator.dupe(u8, attr_name);69        errdefer self.allocator.free(owned_name);7071        var iface_slice: []InterfaceEntry = &.{};72        var owns_interfaces = false;73        if (interfaces.len > 0) {74            iface_slice = try self.allocator.dupe(InterfaceEntry, interfaces);75            std.mem.sort(InterfaceEntry, iface_slice, {}, interfaceLessThan);76            owns_interfaces = true;77        }78        errdefer if (owns_interfaces and iface_slice.len > 0) self.allocator.free(iface_slice);7980        const abstract = try self.allocator.create(AbstractAttribute);81        errdefer self.allocator.destroy(abstract);8283        abstract.* = .{84            .attr_id = self.next_attr_id,85            .name = owned_name,86            .interfaces = iface_slice,87        };8889        const gop = try self.attrs.getOrPut(self.allocator, owned_name);90        if (gop.found_existing) return error.DuplicateAttribute;9192        gop.key_ptr.* = owned_name;93        gop.value_ptr.* = .{94            .abstract = abstract,95            .owns_interfaces = owns_interfaces,96        };97        self.next_attr_id += 1;9899        return abstract;100    }101102    pub fn registerInterface(103        self: *AttributeRegistry,104        attr_name: []const u8,105        entry: InterfaceEntry,106    ) RegisterInterfaceError!void {107        const reg_entry = self.attrs.getPtr(attr_name) orelse return error.UnknownAttribute;108        const abstract: *AbstractAttribute = @constCast(reg_entry.abstract);109110        for (abstract.interfaces) |existing| {111            if (existing.id == entry.id) return error.DuplicateInterface;112        }113114        const old_slice = abstract.interfaces;115        const new_slice = try self.allocator.alloc(InterfaceEntry, old_slice.len + 1);116        if (old_slice.len > 0) {117            @memcpy(new_slice[0..old_slice.len], old_slice);118        }119        new_slice[old_slice.len] = entry;120        std.mem.sort(InterfaceEntry, new_slice, {}, interfaceLessThan);121122        if (reg_entry.owns_interfaces and old_slice.len > 0) {123            self.allocator.free(@constCast(old_slice));124        }125126        reg_entry.owns_interfaces = true;127        abstract.interfaces = new_slice;128    }129130    pub fn registerOrReplaceInterface(131        self: *AttributeRegistry,132        attr_name: []const u8,133        entry: InterfaceEntry,134    ) RegisterOrReplaceInterfaceError!void {135        const reg_entry = self.attrs.getPtr(attr_name) orelse return error.UnknownAttribute;136        const abstract: *AbstractAttribute = @constCast(reg_entry.abstract);137138        const old_slice = abstract.interfaces;139        var replace_index: ?usize = null;140        for (old_slice, 0..) |existing, i| {141            if (existing.id == entry.id) {142                replace_index = i;143                break;144            }145        }146147        const new_len = if (replace_index == null) old_slice.len + 1 else old_slice.len;148        const new_slice = try self.allocator.alloc(InterfaceEntry, new_len);149        if (old_slice.len > 0) {150            @memcpy(new_slice[0..old_slice.len], old_slice);151        }152153        if (replace_index) |idx| {154            new_slice[idx] = entry;155        } else {156            new_slice[old_slice.len] = entry;157        }158        std.mem.sort(InterfaceEntry, new_slice, {}, interfaceLessThan);159160        if (reg_entry.owns_interfaces and old_slice.len > 0) {161            self.allocator.free(@constCast(old_slice));162        }163164        reg_entry.owns_interfaces = true;165        abstract.interfaces = new_slice;166    }167168    pub fn count(self: *const AttributeRegistry) usize {169        return self.attrs.count();170    }171172    pub fn removeAttribute(self: *AttributeRegistry, attr_name: []const u8) bool {173        const removed = self.attrs.fetchRemove(attr_name) orelse return false;174175        const abstract = removed.value.abstract;176        if (removed.value.owns_interfaces and abstract.interfaces.len > 0) {177            self.allocator.free(@constCast(abstract.interfaces));178        }179        self.allocator.destroy(@constCast(abstract));180        self.allocator.free(removed.key);181        return true;182    }183};

1pub const ContextOpaque = opaque {};

1pub const InterfaceEntry = struct {2    id: InterfaceId,3    vtable: *const anyopaque,4};

1pub const TypeParamPayload = struct {2    ptr: *anyopaque,3    deinit: *const fn (allocator: std.mem.Allocator, ptr: *anyopaque) void,4};

1pub const CountRange = struct {2    min: usize = 0,3    max: ?usize = null,45    pub fn exactly(count: usize) CountRange {6        return .{ .min = count, .max = count };7    }89    pub fn atLeast(count: usize) CountRange {10        return .{ .min = count };11    }1213    pub fn atMost(count: usize) CountRange {14        return .{ .max = count };15    }1617    pub fn between(min: usize, max: usize) CountRange {18        return .{ .min = min, .max = max };19    }2021    pub fn allows(self: CountRange, count: usize) bool {22        if (count < self.min) return false;23        if (self.max) |max| {24            if (count > max) return false;25        }26        return true;27    }2829    pub fn hasConstraint(self: CountRange) bool {30        return self.min != 0 or self.max != null;31    }32};

1pub const DiagnosticKind = enum {2    error_,3    warning,4};

1pub const EvalContext = struct {2    state: *anyopaque,3    allocator: std.mem.Allocator,4    emitDiagnostic: *const fn (state: *anyopaque, kind: DiagnosticKind, message: []const u8) EvalError!void,56    evaluateRegion: *const fn (state: *anyopaque, region: *const anyopaque) EvalError!IrAttribute,78    evaluateRegionWithArgs: *const fn (9        state: *anyopaque,10        region: *const anyopaque,11        args: []const IrAttribute,12    ) EvalError!IrAttribute,1314    evaluateSymbol: *const fn (15        state: *anyopaque,16        symbol: []const u8,17        args: []const IrAttribute,18    ) EvalError!IrAttribute,1920    consumeBranchFuel: *const fn (state: *anyopaque) EvalError!void,2122    consumeIterationFuel: *const fn (state: *anyopaque) EvalError!void,2324    allocHandle: *const fn (state: *anyopaque, size: i64) EvalError!i64,2526    borrowHandle: *const fn (state: *anyopaque, handle: i64) EvalError!i64,2728    borrowMutHandle: *const fn (state: *anyopaque, handle: i64) EvalError!i64,2930    moveHandle: *const fn (state: *anyopaque, handle: i64) EvalError!i64,3132    dropHandle: *const fn (state: *anyopaque, handle: i64) EvalError!void,3334    createRewriteBuilder: *const fn (state: *anyopaque, root: *IrOperation) EvalError!*anyopaque,35};

1pub const EvalError = error{2    UnsupportedOperation,3    UnknownEffect,4    EffectViolation,5    LocationViolation,6    DivisionByZero,7    InvalidOperand,8    InvalidConstant,9    RequiresDynamicInfo,10    InvalidShiftAmount,11    InvalidPredicate,12    EvaluationFailed,13    Overflow,14    RecursionDepthExceeded,15    InvalidCondition,16    InvalidSize,17    NegativeSize,18    InvalidHandle,19    HandleAlreadyDropped,20    BorrowOfInvalidHandle,21    MoveOfInvalidHandle,22    BranchQuotaExceeded,23    IterationQuotaExceeded,24    DeviceLocationForbidden,25    UnifiedLocationForbidden,26    YieldMissingOperand,27    NoYield,28    ValueNotFound,29    OutOfMemory,30};

1pub const FoldResult = union(enum) {2    value: *IrValue,3    attribute: IrAttribute,4};

1pub const FoldResults = struct {2    storage: []FoldResult,3    len: usize = 0,45    pub fn init(storage: []FoldResult) FoldResults {6        return .{ .storage = storage };7    }89    pub fn append(self: *FoldResults, result: FoldResult) error{CapacityExceeded}!void {10        std.debug.assert(self.len <= self.storage.len);11        if (self.len == self.storage.len) return error.CapacityExceeded;12        self.storage[self.len] = result;13        self.len += 1;14    }1516    pub fn slice(self: *const FoldResults) []const FoldResult {17        std.debug.assert(self.len <= self.storage.len);18        return self.storage[0..self.len];19    }20};

1pub const OperationInfo = struct {2    pub const dynamic_trait_inline_capacity = traits.TraitIds.inline_capacity;3    pub const interface_inline_capacity = InterfaceEntries.inline_capacity;45    pub const AttributeNameCapacity = struct {6        inherent: usize = 0,7        required: usize = 0,8    };910    name: []const u8,1112    traits: OperationTraits = .{},1314    shape: OperationShape = .{},1516    dynamic_trait_ids: traits.TraitIds = .{},1718    interfaces: InterfaceEntries = .{},1920    inherent_attribute_names: AttributeNameList = .{},2122    required_attribute_names: AttributeNameList = .{},2324    operand_type_constraints: std.ArrayListUnmanaged(OperationTypeConstraint) = .empty,2526    result_type_constraints: std.ArrayListUnmanaged(OperationTypeConstraint) = .empty,2728    operand_segments: ?OperationSegmentSpec = null,2930    result_segments: ?OperationSegmentSpec = null,3132    properties_model: ?OperationPropertiesModel = null,3334    pub const AddTraitError = error{DuplicateTrait} || std.mem.Allocator.Error;3536    pub const AddInterfaceError = error{DuplicateInterface} || std.mem.Allocator.Error;3738    pub const AddInherentAttributeNameError = error{DuplicateInherentAttributeName} || std.mem.Allocator.Error;3940    pub const AddRequiredAttributeNameError = error{DuplicateRequiredAttributeName} || AddInherentAttributeNameError;4142    pub const SetPropertiesModelError = error{43        DuplicateOperationProperties,44        IncompleteOperationPropertiesCodec,45    };46    pub const SetShapeError = error{ConflictingOperationShape};47    pub const SetSegmentSpecError = error{48        EmptySegmentAttributeName,49        EmptyOperationSegments,50        ConflictingOperandSegments,51        ConflictingResultSegments,52    } || std.mem.Allocator.Error;53    pub const AddTypeConstraintError = error{54        DuplicateOperandTypeConstraint,55        DuplicateResultTypeConstraint,56        ConflictingOperandTypeConstraint,57        ConflictingResultTypeConstraint,58    } || std.mem.Allocator.Error;5960    pub fn init(name: []const u8) OperationInfo {61        return .{ .name = name };62    }6364    pub fn initEntryStorage(65        name: []const u8,66        trait_storage: *[dynamic_trait_inline_capacity]TraitId,67        interface_storage: *[interface_inline_capacity]InterfaceEntry,68        inherent_attribute_storage: [][]const u8,69        required_attribute_storage: [][]const u8,70    ) OperationInfo {71        return .{72            .name = name,73            .dynamic_trait_ids = traits.TraitIds.initInline(trait_storage),74            .interfaces = InterfaceEntries.initInline(interface_storage),75            .inherent_attribute_names = initAttributeNameList(inherent_attribute_storage),76            .required_attribute_names = initAttributeNameList(required_attribute_storage),77        };78    }7980    fn initAttributeNameList(storage: [][]const u8) AttributeNameList {81        if (storage.len == 0) return .{};82        return AttributeNameList.initBorrowed(storage);83    }8485    pub fn deinit(self: *OperationInfo, allocator: std.mem.Allocator) void {86        self.dynamic_trait_ids.deinit(allocator);87        self.interfaces.deinit(allocator);88        for (self.inherent_attribute_names.values()) |name| {89            allocator.free(name);90        }91        self.inherent_attribute_names.deinit(allocator);92        for (self.required_attribute_names.values()) |name| {93            allocator.free(name);94        }95        self.required_attribute_names.deinit(allocator);96        for (self.operand_type_constraints.items) |constraint| {97            allocator.free(constraint.type_name);98        }99        self.operand_type_constraints.deinit(allocator);100        for (self.result_type_constraints.items) |constraint| {101            allocator.free(constraint.type_name);102        }103        self.result_type_constraints.deinit(allocator);104        if (self.operand_segments) |segment_spec| {105            freeSegmentSpec(allocator, segment_spec);106        }107        if (self.result_segments) |segment_spec| {108            freeSegmentSpec(allocator, segment_spec);109        }110    }111112    pub fn addTrait(113        self: *OperationInfo,114        allocator: std.mem.Allocator,115        trait_id: TraitId,116    ) AddTraitError!void {117        try self.dynamic_trait_ids.insert(allocator, trait_id);118    }119120    pub fn addInterface(121        self: *OperationInfo,122        allocator: std.mem.Allocator,123        entry: InterfaceEntry,124    ) AddInterfaceError!void {125        try self.interfaces.insert(allocator, entry);126    }127128    pub fn addOrReplaceInterface(129        self: *OperationInfo,130        allocator: std.mem.Allocator,131        entry: InterfaceEntry,132    ) !void {133        try self.interfaces.insertOrReplace(allocator, entry);134    }135136    pub fn addInherentAttributeName(137        self: *OperationInfo,138        allocator: std.mem.Allocator,139        name: []const u8,140    ) AddInherentAttributeNameError!void {141        if (self.hasInherentAttributeName(name)) return error.DuplicateInherentAttributeName;142143        const owned_name = try allocator.dupe(u8, name);144        errdefer allocator.free(owned_name);145146        try self.inherent_attribute_names.append(allocator, owned_name);147148        std.mem.sort(149            []const u8,150            self.inherent_attribute_names.valuesMut(),151            {},152            name_less_than,153        );154    }155156    pub fn addInherentAttributeNames(157        self: *OperationInfo,158        allocator: std.mem.Allocator,159        names: []const []const u8,160    ) AddInherentAttributeNameError!void {161        for (names) |name| {162            try self.addInherentAttributeName(allocator, name);163        }164    }165166    pub fn getInherentAttributeNames(self: *const OperationInfo) []const []const u8 {167        return self.inherent_attribute_names.values();168    }169170    pub fn hasInherentAttributeName(self: *const OperationInfo, name: []const u8) bool {171        return sortedNameContains(self.inherent_attribute_names.values(), name);172    }173174    pub fn addRequiredAttributeName(175        self: *OperationInfo,176        allocator: std.mem.Allocator,177        name: []const u8,178    ) AddRequiredAttributeNameError!void {179        if (!self.hasInherentAttributeName(name)) {180            try self.addInherentAttributeName(allocator, name);181        }182        if (self.hasRequiredAttributeName(name)) return error.DuplicateRequiredAttributeName;183184        const owned_name = try allocator.dupe(u8, name);185        errdefer allocator.free(owned_name);186187        try self.required_attribute_names.append(allocator, owned_name);188189        std.mem.sort(190            []const u8,191            self.required_attribute_names.valuesMut(),192            {},193            name_less_than,194        );195    }196197    pub fn addRequiredAttributeNames(198        self: *OperationInfo,199        allocator: std.mem.Allocator,200        names: []const []const u8,201    ) AddRequiredAttributeNameError!void {202        for (names) |name| {203            try self.addRequiredAttributeName(allocator, name);204        }205    }206207    pub fn getRequiredAttributeNames(self: *const OperationInfo) []const []const u8 {208        return self.required_attribute_names.values();209    }210211    pub fn hasRequiredAttributeName(self: *const OperationInfo, name: []const u8) bool {212        return sortedNameContains(self.required_attribute_names.values(), name);213    }214215    fn sortedNameContains(names: []const []const u8, name: []const u8) bool {216        var left: usize = 0;217        var right: usize = names.len;218        while (left < right) {219            const mid = left + (right - left) / 2;220            const cmp = std.mem.order(u8, names[mid], name);221            switch (cmp) {222                .eq => return true,223                .lt => left = mid + 1,224                .gt => right = mid,225            }226        }227        return false;228    }229230    pub fn setPropertiesModel(231        self: *OperationInfo,232        model: OperationPropertiesModel,233    ) SetPropertiesModelError!void {234        if (self.properties_model != null) return error.DuplicateOperationProperties;235        if ((model.getPropertiesAsAttr == null) != (model.setPropertiesFromAttr == null)) {236            return error.IncompleteOperationPropertiesCodec;237        }238        self.properties_model = model;239    }240241    pub fn getPropertiesModel(self: *const OperationInfo) ?*const OperationPropertiesModel {242        if (self.properties_model) |*model| return model;243        return null;244    }245246    pub fn hasPropertiesModel(self: *const OperationInfo) bool {247        return self.properties_model != null;248    }249250    pub fn setShape(251        self: *OperationInfo,252        shape: OperationShape,253    ) SetShapeError!void {254        if (self.shape.hasConstraints() and !self.shape.eql(shape)) {255            return error.ConflictingOperationShape;256        }257        self.shape = shape;258    }259260    pub fn setOperandSegments(261        self: *OperationInfo,262        allocator: std.mem.Allocator,263        spec: OperationSegmentSpec,264    ) SetSegmentSpecError!void {265        try self.setSegmentSpec(allocator, &self.operand_segments, spec, error.ConflictingOperandSegments);266    }267268    pub fn setResultSegments(269        self: *OperationInfo,270        allocator: std.mem.Allocator,271        spec: OperationSegmentSpec,272    ) SetSegmentSpecError!void {273        try self.setSegmentSpec(allocator, &self.result_segments, spec, error.ConflictingResultSegments);274    }275276    fn setSegmentSpec(277        self: *OperationInfo,278        allocator: std.mem.Allocator,279        slot: *?OperationSegmentSpec,280        spec: OperationSegmentSpec,281        conflict: SetSegmentSpecError,282    ) SetSegmentSpecError!void {283        _ = self;284        if (spec.attribute_name.len == 0) return error.EmptySegmentAttributeName;285        if (spec.segments.len == 0) return error.EmptyOperationSegments;286        if (slot.*) |existing| {287            if (existing.eql(spec)) return;288            return conflict;289        }290291        const owned_name = try allocator.dupe(u8, spec.attribute_name);292        errdefer allocator.free(owned_name);293        const owned_segments = try allocator.dupe(CountRange, spec.segments);294        errdefer allocator.free(owned_segments);295        slot.* = .{296            .attribute_name = owned_name,297            .segments = owned_segments,298        };299    }300301    pub fn addOperandTypeConstraint(302        self: *OperationInfo,303        allocator: std.mem.Allocator,304        constraint: OperationTypeConstraint,305    ) AddTypeConstraintError!void {306        try self.addTypeConstraint(307            allocator,308            &self.operand_type_constraints,309            constraint,310            error.DuplicateOperandTypeConstraint,311            error.ConflictingOperandTypeConstraint,312        );313    }314315    pub fn addResultTypeConstraint(316        self: *OperationInfo,317        allocator: std.mem.Allocator,318        constraint: OperationTypeConstraint,319    ) AddTypeConstraintError!void {320        try self.addTypeConstraint(321            allocator,322            &self.result_type_constraints,323            constraint,324            error.DuplicateResultTypeConstraint,325            error.ConflictingResultTypeConstraint,326        );327    }328329    fn addTypeConstraint(330        self: *OperationInfo,331        allocator: std.mem.Allocator,332        list: *std.ArrayListUnmanaged(OperationTypeConstraint),333        constraint: OperationTypeConstraint,334        duplicate: AddTypeConstraintError,335        conflict: AddTypeConstraintError,336    ) AddTypeConstraintError!void {337        _ = self;338        for (list.items) |existing| {339            if (existing.index == constraint.index) {340                if (existing.eql(constraint)) return duplicate;341                return conflict;342            }343        }344345        const owned_name = try allocator.dupe(u8, constraint.type_name);346        errdefer allocator.free(owned_name);347        try list.append(allocator, .{348            .index = constraint.index,349            .type_name = owned_name,350            .allow_parameterized = constraint.allow_parameterized,351        });352        std.mem.sort(OperationTypeConstraint, list.items, {}, type_constraint_less_than);353    }354355    pub fn getOperandTypeConstraints(self: *const OperationInfo) []const OperationTypeConstraint {356        return self.operand_type_constraints.items;357    }358359    pub fn getResultTypeConstraints(self: *const OperationInfo) []const OperationTypeConstraint {360        return self.result_type_constraints.items;361    }362363    pub fn getOperandSegments(self: *const OperationInfo) ?OperationSegmentSpec {364        return self.operand_segments;365    }366367    pub fn getResultSegments(self: *const OperationInfo) ?OperationSegmentSpec {368        return self.result_segments;369    }370371    pub fn getInterface(self: *const OperationInfo, id: InterfaceId) ?*const anyopaque {372        return self.interfaces.get(id);373    }374375    pub fn hasTraitId(self: *const OperationInfo, trait_id: TraitId) bool {376        return self.dynamic_trait_ids.contains(trait_id);377    }378379    pub fn getDynamicTraitIds(self: *const OperationInfo) []const TraitId {380        return self.dynamic_trait_ids.values();381    }382383    pub fn hasInterface(self: *const OperationInfo, id: InterfaceId) bool {384        return self.getInterface(id) != null;385    }386387    pub fn getNumInterfaces(self: *const OperationInfo) usize {388        return self.interfaces.count();389    }390};

1pub const OperationRegistry = struct {2    allocator: std.mem.Allocator,34    ops: std.StringHashMapUnmanaged(*OperationInfo),5    batch_regions: ?*BatchEntryStorage.RegionOwner,67    allow_unregistered_operations: bool,89    pub const RegisterPropertiesModelError = OperationInfo.SetPropertiesModelError || GetOrCreateError;10    pub const RegisterShapeError = OperationInfo.SetShapeError || GetOrCreateError;11    pub const RegisterSegmentSpecError = OperationInfo.SetSegmentSpecError || GetOrCreateError;12    pub const RegisterTypeConstraintError = OperationInfo.AddTypeConstraintError || GetOrCreateError;1314    pub const GetOrCreateError: type = std.mem.Allocator.Error;1516    pub const GetOrCreateResult = struct {17        info: *OperationInfo,18        created: bool,19    };2021    pub const RegisterTraitError: type = OperationInfo.AddTraitError;22    pub const RegisterInterfaceError: type = OperationInfo.AddInterfaceError;23    pub const RegisterInherentAttributeNameError: type =24        OperationInfo.AddInherentAttributeNameError;25    pub const RegisterRequiredAttributeNameError: type =26        OperationInfo.AddRequiredAttributeNameError;2728    const EntryStorage: type = registry_entry.InlineStorage(29        OperationInfo,30        TraitId,31        OperationInfo.dynamic_trait_inline_capacity,32        InterfaceEntry,33        OperationInfo.interface_inline_capacity,34        []const u8,35        []const u8,36    );37    const BatchEntryStorage: type = EntryStorage.BatchStorage;3839    pub fn init(allocator: std.mem.Allocator) OperationRegistry {40        return .{41            .allocator = allocator,42            .ops = .{},43            .batch_regions = null,44            .allow_unregistered_operations = false,45        };46    }4748    pub fn deinit(self: *OperationRegistry) void {49        var it = self.ops.valueIterator();50        while (it.next()) |info_ptr| {51            const info = info_ptr.*;52            if (self.findBatchRegionLink(info) != null) {53                info.deinit(self.allocator);54                info.* = undefined;55            } else {56                EntryStorage.destroy(self.allocator, info);57            }58        }59        self.ops.deinit(self.allocator);60        while (self.batch_regions) |region| {61            self.batch_regions = region.next;62            BatchEntryStorage.destroy(self.allocator, region);63        }64    }6566    pub fn lookup(self: *const OperationRegistry, op_name: []const u8) ?*OperationInfo {67        return self.ops.get(op_name);68    }6970    pub fn getOrCreate(self: *OperationRegistry, op_name: []const u8) GetOrCreateError!*OperationInfo {71        return (try self.getOrCreateTracked(op_name)).info;72    }7374    pub fn getOrCreateTracked(self: *OperationRegistry, op_name: []const u8) GetOrCreateError!GetOrCreateResult {75        return self.getOrCreateTrackedWithAttributeNameCapacity(op_name, .{});76    }7778    pub fn getOrCreateTrackedWithAttributeNameCapacity(79        self: *OperationRegistry,80        op_name: []const u8,81        capacity: OperationInfo.AttributeNameCapacity,82    ) GetOrCreateError!GetOrCreateResult {83        if (self.ops.get(op_name)) |existing| {84            return .{ .info = existing, .created = false };85        }8687        const info = try EntryStorage.create(88            self.allocator,89            op_name,90            capacity.inherent,91            capacity.required,92        );93        errdefer EntryStorage.destroy(self.allocator, info);9495        const gop = try self.ops.getOrPut(self.allocator, info.name);96        if (gop.found_existing) {97            EntryStorage.destroy(self.allocator, info);98            return .{ .info = gop.value_ptr.*, .created = false };99        }100101        gop.value_ptr.* = info;102        return .{ .info = info, .created = true };103    }104105    pub fn getOrCreateOperationBatch(106        self: *OperationRegistry,107        operation_specs: anytype,108    ) GetOrCreateError!void {109        var capacity_value: BatchEntryStorage.Capacity = .{};110        for (operation_specs) |op| {111            if (self.ops.get(op.name) != null) continue;112            capacity_value.add(113                op.name.len,114                op.inherent_attribute_names.len,115                op.required_attribute_names.len,116            ) catch return error.OutOfMemory;117        }118        if (capacity_value.entry_count == 0) return;119        const unused_capacity = std.math.cast(120            u32,121            capacity_value.entry_count,122        ) orelse return error.OutOfMemory;123124        const allocation = try BatchEntryStorage.create(125            self.allocator,126            capacity_value,127        );128        errdefer BatchEntryStorage.destroy(self.allocator, allocation.region);129130        try self.ops.ensureUnusedCapacity(self.allocator, unused_capacity);131        var cursor = BatchEntryStorage.Cursor.init(allocation.entries);132        for (operation_specs) |op| {133            if (self.ops.get(op.name) != null) continue;134            const info = cursor.create(135                op.name,136                op.inherent_attribute_names.len,137                op.required_attribute_names.len,138            );139            self.ops.putAssumeCapacityNoClobber(info.name, info);140        }141        std.debug.assert(cursor.offset <= allocation.entries.len);142143        allocation.region.next = self.batch_regions;144        self.batch_regions = allocation.region;145    }146147    pub fn registerOperation(148        self: *OperationRegistry,149        op_name: []const u8,150        traits_val: OperationTraits,151    ) GetOrCreateError!*OperationInfo {152        const info = try self.getOrCreate(op_name);153        info.traits = info.traits.merge(traits_val);154        return info;155    }156157    pub fn registerTrait(158        self: *OperationRegistry,159        op_name: []const u8,160        trait_id: TraitId,161    ) RegisterTraitError!void {162        const info = try self.getOrCreate(op_name);163        try info.addTrait(self.allocator, trait_id);164    }165166    pub fn registerInterface(167        self: *OperationRegistry,168        op_name: []const u8,169        entry: InterfaceEntry,170    ) RegisterInterfaceError!void {171        const info = try self.getOrCreate(op_name);172        try info.addInterface(self.allocator, entry);173    }174175    pub fn registerOrReplaceInterface(176        self: *OperationRegistry,177        op_name: []const u8,178        entry: InterfaceEntry,179    ) GetOrCreateError!void {180        const info = try self.getOrCreate(op_name);181        try info.addOrReplaceInterface(self.allocator, entry);182    }183184    pub fn registerInherentAttributeName(185        self: *OperationRegistry,186        op_name: []const u8,187        attr_name: []const u8,188    ) RegisterInherentAttributeNameError!void {189        const info = try self.getOrCreate(op_name);190        try info.addInherentAttributeName(self.allocator, attr_name);191    }192193    pub fn registerRequiredAttributeName(194        self: *OperationRegistry,195        op_name: []const u8,196        attr_name: []const u8,197    ) RegisterRequiredAttributeNameError!void {198        const info = try self.getOrCreate(op_name);199        try info.addRequiredAttributeName(self.allocator, attr_name);200    }201202    pub fn registerInherentAttributeNames(203        self: *OperationRegistry,204        op_name: []const u8,205        attr_names: []const []const u8,206    ) RegisterInherentAttributeNameError!void {207        const info = try self.getOrCreate(op_name);208        try info.addInherentAttributeNames(self.allocator, attr_names);209    }210211    pub fn registerPropertiesModel(212        self: *OperationRegistry,213        op_name: []const u8,214        model: OperationPropertiesModel,215    ) RegisterPropertiesModelError!void {216        const info = try self.getOrCreate(op_name);217        try info.setPropertiesModel(model);218    }219220    pub fn registerShape(221        self: *OperationRegistry,222        op_name: []const u8,223        shape: OperationShape,224    ) RegisterShapeError!void {225        const info = try self.getOrCreate(op_name);226        try info.setShape(shape);227    }228229    pub fn registerOperandSegments(230        self: *OperationRegistry,231        op_name: []const u8,232        spec: OperationSegmentSpec,233    ) RegisterSegmentSpecError!void {234        const info = try self.getOrCreate(op_name);235        try info.setOperandSegments(self.allocator, spec);236    }237238    pub fn registerResultSegments(239        self: *OperationRegistry,240        op_name: []const u8,241        spec: OperationSegmentSpec,242    ) RegisterSegmentSpecError!void {243        const info = try self.getOrCreate(op_name);244        try info.setResultSegments(self.allocator, spec);245    }246247    pub fn registerOperandTypeConstraint(248        self: *OperationRegistry,249        op_name: []const u8,250        constraint: OperationTypeConstraint,251    ) RegisterTypeConstraintError!void {252        const info = try self.getOrCreate(op_name);253        try info.addOperandTypeConstraint(self.allocator, constraint);254    }255256    pub fn registerResultTypeConstraint(257        self: *OperationRegistry,258        op_name: []const u8,259        constraint: OperationTypeConstraint,260    ) RegisterTypeConstraintError!void {261        const info = try self.getOrCreate(op_name);262        try info.addResultTypeConstraint(self.allocator, constraint);263    }264265    pub fn count(self: *const OperationRegistry) usize {266        return self.ops.count();267    }268269    pub fn removeOperation(self: *OperationRegistry, op_name: []const u8) bool {270        const removed = self.ops.fetchRemove(op_name) orelse return false;271        const info = removed.value;272        std.debug.assert(removed.key.ptr == info.name.ptr);273        if (self.findBatchRegionLink(info)) |region_link| {274            const region = region_link.*.?;275            info.deinit(self.allocator);276            info.* = undefined;277            if (!self.batchRegionHasLiveInfo(region)) {278                region_link.* = region.next;279                BatchEntryStorage.destroy(self.allocator, region);280            }281        } else {282            EntryStorage.destroy(self.allocator, info);283        }284        return true;285    }286287    fn findBatchRegionLink(288        self: *OperationRegistry,289        info: *const OperationInfo,290    ) ?*?*BatchEntryStorage.RegionOwner {291        var region_link = &self.batch_regions;292        while (region_link.*) |region| {293            if (BatchEntryStorage.contains(region, info)) return region_link;294            region_link = &region.next;295        }296        return null;297    }298299    fn batchRegionHasLiveInfo(300        self: *const OperationRegistry,301        region: *const BatchEntryStorage.RegionOwner,302    ) bool {303        var it = self.ops.valueIterator();304        while (it.next()) |info_ptr| {305            if (BatchEntryStorage.contains(region, info_ptr.*)) return true;306        }307        return false;308    }309};

1pub const OperationSegmentSpec = struct {2    attribute_name: []const u8,3    segments: []const CountRange,45    pub fn hasSegments(self: OperationSegmentSpec) bool {6        return self.segments.len > 0;7    }89    pub fn eql(self: OperationSegmentSpec, other: OperationSegmentSpec) bool {10        if (!std.mem.eql(u8, self.attribute_name, other.attribute_name)) return false;11        if (self.segments.len != other.segments.len) return false;12        for (self.segments, other.segments) |a, b| {13            if (!std.meta.eql(a, b)) return false;14        }15        return true;16    }1718    pub fn size(self: OperationSegmentSpec, op: *const IrOperation, index: usize) ?usize {19        if (index >= self.segments.len) return null;20        const attr = op.getAttrAs(IrAttribute.ArrayAttr, self.attribute_name) orelse return null;21        const values = attr.getValues();22        if (index >= values.len) return null;23        const int_attr = values[index].cast(IrAttribute.IntegerAttr) orelse return null;24        return std.math.cast(usize, int_attr.getValue());25    }2627    pub fn offset(self: OperationSegmentSpec, op: *const IrOperation, index: usize) ?usize {28        if (index > self.segments.len) return null;29        const attr = op.getAttrAs(IrAttribute.ArrayAttr, self.attribute_name) orelse return null;30        const values = attr.getValues();31        if (index > values.len) return null;32        var result: usize = 0;33        for (values[0..index]) |value| {34            const int_attr = value.cast(IrAttribute.IntegerAttr) orelse return null;35            const size_value = std.math.cast(usize, int_attr.getValue()) orelse return null;36            result = std.math.add(usize, result, size_value) catch return null;37        }38        return result;39    }40};

1pub const OperationShape = struct {2    operands: CountRange = .{},3    results: CountRange = .{},4    regions: CountRange = .{},5    successors: CountRange = .{},67    pub fn hasConstraints(self: OperationShape) bool {8        return self.operands.hasConstraint() or9            self.results.hasConstraint() or10            self.regions.hasConstraint() or11            self.successors.hasConstraint();12    }1314    pub fn eql(self: OperationShape, other: OperationShape) bool {15        return std.meta.eql(self, other);16    }17};

1pub const OperationTypeConstraint = struct {2    index: usize,3    type_name: []const u8,4    allow_parameterized: bool = false,56    pub fn eql(self: OperationTypeConstraint, other: OperationTypeConstraint) bool {7        return self.index == other.index and8            self.allow_parameterized == other.allow_parameterized and9            std.mem.eql(u8, self.type_name, other.type_name);10    }11};

1pub const RegionKind = enum {2    ssacfg,3    graph,4};

1pub const OperationTraits = packed struct(u64) {2    is_terminator: bool = false,3    is_commutative: bool = false,4    is_idempotent: bool = false,5    is_involution: bool = false,6    is_symbol_table: bool = false,7    has_no_terminator: bool = false,8    has_only_graph_regions: bool = false,9    _padding: u57 = 0,1011    pub fn merge(a: OperationTraits, b: OperationTraits) OperationTraits {12        return .{13            .is_terminator = a.is_terminator or b.is_terminator,14            .is_commutative = a.is_commutative or b.is_commutative,15            .is_idempotent = a.is_idempotent or b.is_idempotent,16            .is_involution = a.is_involution or b.is_involution,17            .is_symbol_table = a.is_symbol_table or b.is_symbol_table,18            .has_no_terminator = a.has_no_terminator or b.has_no_terminator,19            .has_only_graph_regions = a.has_only_graph_regions or b.has_only_graph_regions,20        };21    }22};

1pub const TraitEntry = struct {2    id: TraitId,3    vtable: *const TraitVTable,4};

1pub const TraitRegistry = struct {2    traits: std.AutoHashMapUnmanaged(TraitId, *const TraitVTable),34    pub const RegisterError = error{DuplicateTrait} || std.mem.Allocator.Error;56    pub fn init() TraitRegistry {7        return .{ .traits = .{} };8    }910    pub fn deinit(self: *TraitRegistry, allocator: std.mem.Allocator) void {11        self.traits.deinit(allocator);12    }1314    pub fn register(15        self: *TraitRegistry,16        allocator: std.mem.Allocator,17        entry: TraitEntry,18    ) RegisterError!void {19        const gop = try self.traits.getOrPut(allocator, entry.id);20        if (gop.found_existing) return error.DuplicateTrait;21        gop.value_ptr.* = entry.vtable;22    }2324    pub fn lookup(self: *const TraitRegistry, id: TraitId) ?*const TraitVTable {25        return self.traits.get(id);26    }2728    pub fn count(self: *const TraitRegistry) usize {29        return self.traits.count();30    }31};

1pub const TraitVTable = struct {2    verify: ?*const fn (op_ptr: *const anyopaque) anyerror!void = null,3    verify_regions: ?*const fn (op_ptr: *const anyopaque) anyerror!void = null,4};

1pub const TypeInfo = struct {2    name: []const u8,34    interfaces: InterfaceEntries = .{},56    pub const AddInterfaceError = error{DuplicateInterface} || std.mem.Allocator.Error;78    pub fn init(name: []const u8) TypeInfo {9        return .{ .name = name };10    }1112    pub fn deinit(self: *TypeInfo, allocator: std.mem.Allocator) void {13        self.interfaces.deinit(allocator);14    }1516    pub fn addInterface(17        self: *TypeInfo,18        allocator: std.mem.Allocator,19        entry: InterfaceEntry,20    ) AddInterfaceError!void {21        try self.interfaces.insert(allocator, entry);22    }2324    pub fn addOrReplaceInterface(25        self: *TypeInfo,26        allocator: std.mem.Allocator,27        entry: InterfaceEntry,28    ) !void {29        try self.interfaces.insertOrReplace(allocator, entry);30    }3132    pub fn getInterface(self: *const TypeInfo, id: InterfaceId) ?*const anyopaque {33        return self.interfaces.get(id);34    }3536    pub fn hasInterface(self: *const TypeInfo, id: InterfaceId) bool {37        return self.getInterface(id) != null;38    }3940    pub fn getNumInterfaces(self: *const TypeInfo) usize {41        return self.interfaces.count();42    }43};

1pub const TypeRegistry = struct {2    allocator: std.mem.Allocator,34    types: std.StringHashMapUnmanaged(*TypeInfo),5    batch_regions: ?*BatchEntryStorage.RegionOwner,67    allow_unregistered_types: bool,89    pub const GetOrCreateError: type = std.mem.Allocator.Error;1011    pub const GetOrCreateResult = struct {12        info: *TypeInfo,13        created: bool,14    };1516    pub const RegisterInterfaceError: type = TypeInfo.AddInterfaceError;1718    const EntryStorage: type = registry_entry.Storage(TypeInfo);19    const BatchEntryStorage: type = registry_entry.BatchStorage(TypeInfo);2021    pub fn init(allocator: std.mem.Allocator) TypeRegistry {22        return .{23            .allocator = allocator,24            .types = .{},25            .batch_regions = null,26            .allow_unregistered_types = false,27        };28    }2930    pub fn deinit(self: *TypeRegistry) void {31        var it = self.types.valueIterator();32        while (it.next()) |info_ptr| {33            const info = info_ptr.*;34            if (self.findBatchRegionLink(info) != null) {35                info.deinit(self.allocator);36                info.* = undefined;37            } else {38                EntryStorage.destroy(self.allocator, info);39            }40        }41        self.types.deinit(self.allocator);42        while (self.batch_regions) |region| {43            self.batch_regions = region.next;44            BatchEntryStorage.destroy(self.allocator, region);45        }46    }4748    pub fn lookup(self: *const TypeRegistry, type_name: []const u8) ?*TypeInfo {49        return self.types.get(type_name);50    }5152    pub fn getOrCreate(self: *TypeRegistry, type_name: []const u8) GetOrCreateError!*TypeInfo {53        return (try self.getOrCreateTracked(type_name)).info;54    }5556    pub fn getOrCreateTracked(self: *TypeRegistry, type_name: []const u8) GetOrCreateError!GetOrCreateResult {57        if (self.types.get(type_name)) |existing| {58            return .{ .info = existing, .created = false };59        }6061        const info = try EntryStorage.create(self.allocator, type_name);62        errdefer EntryStorage.destroy(self.allocator, info);6364        const gop = try self.types.getOrPut(self.allocator, info.name);65        if (gop.found_existing) {66            EntryStorage.destroy(self.allocator, info);67            return .{ .info = gop.value_ptr.*, .created = false };68        }6970        gop.value_ptr.* = info;71        return .{ .info = info, .created = true };72    }7374    pub fn getOrCreateNamedBatch(self: *TypeRegistry, named_items: anytype) GetOrCreateError!void {75        try self.getOrCreateBatch(named_items);76    }7778    fn getOrCreateBatch(79        self: *TypeRegistry,80        items: anytype,81    ) GetOrCreateError!void {82        var info_count: usize = 0;83        var name_bytes: usize = 0;84        for (items) |item| {85            const name = batchItemName(item);86            if (self.types.get(name) != null) continue;87            info_count = std.math.add(usize, info_count, 1) catch return error.OutOfMemory;88            name_bytes = std.math.add(usize, name_bytes, name.len) catch return error.OutOfMemory;89        }90        if (info_count == 0) return;91        const unused_capacity = std.math.cast(u32, info_count) orelse return error.OutOfMemory;9293        const allocation = try BatchEntryStorage.create(self.allocator, info_count, name_bytes);94        errdefer BatchEntryStorage.destroy(self.allocator, allocation.region);9596        var info_index: usize = 0;97        var name_offset: usize = 0;98        for (items) |item| {99            const name = batchItemName(item);100            if (self.types.get(name) != null) continue;101            const name_end = std.math.add(usize, name_offset, name.len) catch unreachable;102            const owned_name = allocation.names[name_offset..name_end];103            @memcpy(owned_name, name);104            allocation.infos[info_index] = TypeInfo.init(owned_name);105            info_index += 1;106            name_offset = name_end;107        }108        std.debug.assert(info_index == allocation.infos.len);109        std.debug.assert(name_offset == allocation.names.len);110111        try self.types.ensureUnusedCapacity(self.allocator, unused_capacity);112        for (allocation.infos) |*info| {113            if (self.types.get(info.name) != null) continue;114            self.types.putAssumeCapacityNoClobber(info.name, info);115        }116117        allocation.region.next = self.batch_regions;118        self.batch_regions = allocation.region;119    }120121    fn batchItemName(item: anytype) []const u8 {122        if (@TypeOf(item) == []const u8) return item;123        return item.name;124    }125126    pub fn registerType(self: *TypeRegistry, type_name: []const u8) GetOrCreateError!*TypeInfo {127        return self.getOrCreate(type_name);128    }129130    pub fn registerInterface(131        self: *TypeRegistry,132        type_name: []const u8,133        entry: InterfaceEntry,134    ) RegisterInterfaceError!void {135        const info = try self.getOrCreate(type_name);136        try info.addInterface(self.allocator, entry);137    }138139    pub fn registerOrReplaceInterface(140        self: *TypeRegistry,141        type_name: []const u8,142        entry: InterfaceEntry,143    ) !void {144        const info = try self.getOrCreate(type_name);145        try info.addOrReplaceInterface(self.allocator, entry);146    }147148    pub fn count(self: *const TypeRegistry) usize {149        return self.types.count();150    }151152    pub fn removeType(self: *TypeRegistry, type_name: []const u8) bool {153        const removed = self.types.fetchRemove(type_name) orelse return false;154        const info = removed.value;155        std.debug.assert(removed.key.ptr == info.name.ptr);156        if (self.findBatchRegionLink(info)) |region_link| {157            const region = region_link.*.?;158            info.deinit(self.allocator);159            info.* = undefined;160            if (!self.batchRegionHasLiveInfo(region)) {161                region_link.* = region.next;162                BatchEntryStorage.destroy(self.allocator, region);163            }164        } else {165            EntryStorage.destroy(self.allocator, info);166        }167        return true;168    }169170    fn findBatchRegionLink(171        self: *TypeRegistry,172        info: *const TypeInfo,173    ) ?*?*BatchEntryStorage.RegionOwner {174        var region_link = &self.batch_regions;175        while (region_link.*) |region| {176            if (BatchEntryStorage.contains(region, info)) return region_link;177            region_link = &region.next;178        }179        return null;180    }181182    fn batchRegionHasLiveInfo(183        self: *const TypeRegistry,184        region: *const BatchEntryStorage.RegionOwner,185    ) bool {186        var it = self.types.valueIterator();187        while (it.next()) |info_ptr| {188            if (BatchEntryStorage.contains(region, info_ptr.*)) return true;189        }190        return false;191    }192};

1pub const InterfaceId = u64;

1pub fn castContext(comptime CtxT: type, ctx_ptr: *const ContextOpaque) *CtxT {2    return @ptrCast(@alignCast(@constCast(ctx_ptr)));3}

1pub fn interfaceId(comptime name: []const u8) InterfaceId {2    return std.hash.Wyhash.hash(0, name);3}

1pub fn interfaceIdRuntime(name: []const u8) InterfaceId {2    return std.hash.Wyhash.hash(0, name);3}

1pub fn InlineList(comptime Item: type, comptime inline_capacity: usize) type {2    const inline_mask = @as(usize, 1) << (@bitSizeOf(usize) - 1);34    return struct {5        const Self = @This();67        slice: []Item = &.{},8        capacity_and_inline: usize = 0,910        pub fn initInline(storage: *[inline_capacity]Item) Self {11            return initBorrowed(storage);12        }1314        pub fn initBorrowed(storage: []Item) Self {15            std.debug.assert(storage.len & inline_mask == 0);16            return .{17                .slice = storage[0..0],18                .capacity_and_inline = inline_mask | storage.len,19            };20        }2122        pub fn initBorrowedValues(storage: []Item, values_to_copy: []const Item) Self {23            std.debug.assert(storage.len & inline_mask == 0);24            std.debug.assert(values_to_copy.len <= storage.len);25            @memcpy(storage[0..values_to_copy.len], values_to_copy);26            return .{27                .slice = storage[0..values_to_copy.len],28                .capacity_and_inline = inline_mask | storage.len,29            };30        }3132        pub fn deinit(self: *Self, allocator: Allocator) void {33            if (!self.isInline() and self.capacity() > 0) {34                allocator.free(self.slice.ptr[0..self.capacity()]);35            }36            self.* = .{};37        }3839        pub fn append(self: *Self, allocator: Allocator, item: Item) Allocator.Error!void {40            const capacity_value = self.capacity();41            if (self.slice.len < capacity_value) {42                self.slice.ptr[self.slice.len] = item;43                self.slice.len += 1;44                return;45            }4647            if (self.isInline()) {48                std.debug.assert(self.slice.len == capacity_value);49                const heap_capacity = std.math.add(usize, capacity_value, 1) catch {50                    return error.OutOfMemory;51                };52                const heap_items = try allocator.alloc(Item, heap_capacity);53                errdefer allocator.free(heap_items);54                @memcpy(heap_items[0..capacity_value], self.slice);55                heap_items[capacity_value] = item;56                self.slice = heap_items;57                self.capacity_and_inline = heap_items.len;58                return;59            }6061            var heap: std.ArrayListUnmanaged(Item) = .{62                .items = self.slice,63                .capacity = capacity_value,64            };65            try heap.append(allocator, item);66            std.debug.assert(heap.capacity & inline_mask == 0);67            self.slice = heap.items;68            self.capacity_and_inline = heap.capacity;69        }7071        pub fn values(self: *const Self) []const Item {72            return self.slice;73        }7475        pub fn valuesMut(self: *Self) []Item {76            return self.slice;77        }7879        fn capacity(self: *const Self) usize {80            return self.capacity_and_inline & ~inline_mask;81        }8283        fn isInline(self: *const Self) bool {84            return self.capacity_and_inline & inline_mask != 0;85        }86    };87}