tiny.choir.Attribute

1pub const Attribute = struct {2    attr_id: AttrID,34    impl: *const anyopaque,56    abstract: *const interfaces.AbstractAttribute,78    pub const AttrID = enum(u32) {9        invalid = 0,10        _,11    };1213    pub const first_dynamic_attr_id: u32 = @backingInt(AttrID.invalid) + 1;1415    pub const DialectAttr = struct {16        payload: []const u8,17        context: *const anyopaque,18    };1920    pub const IntegerAttr = struct {21        value: i64,22        width: u8,23        is_signed: bool,24        context: *const anyopaque,2526        pub fn getValue(self: *const IntegerAttr) i64 {27            return self.value;28        }2930        pub fn getUnsignedValue(self: *const IntegerAttr) u64 {31            return @bitCast(self.value);32        }33    };3435    pub const FloatAttr = struct {36        value: f64,37        width: u8,38        context: *const anyopaque,3940        pub fn getValue(self: *const FloatAttr) f64 {41            return self.value;42        }4344        pub fn getF32Value(self: *const FloatAttr) f32 {45            return @floatCast(self.value);46        }47    };4849    pub const BoolAttr = struct {50        value: bool,51        context: *const anyopaque,5253        pub fn getValue(self: *const BoolAttr) bool {54            return self.value;55        }56    };5758    pub const StringAttr = struct {59        value: []const u8,60        context: *const anyopaque,6162        pub fn getValue(self: *const StringAttr) []const u8 {63            return self.value;64        }65    };6667    pub const SymbolRefAttr = struct {68        root_reference: []const u8,69        nested_references: []const []const u8,70        context: *const anyopaque,7172        pub fn getRootReference(self: *const SymbolRefAttr) []const u8 {73            return self.root_reference;74        }7576        pub fn getNestedReferences(self: *const SymbolRefAttr) []const []const u8 {77            return self.nested_references;78        }7980        pub fn getLeafReference(self: *const SymbolRefAttr) []const u8 {81            if (self.nested_references.len == 0) return self.root_reference;82            return self.nested_references[self.nested_references.len - 1];83        }8485        pub fn isFlat(self: *const SymbolRefAttr) bool {86            return self.nested_references.len == 0;87        }88    };8990    pub const StringListAttr = struct {91        values: []const []const u8,92        context: *const anyopaque,9394        pub fn getValues(self: *const StringListAttr) []const []const u8 {95            return self.values;96        }97    };9899    pub const TypeListAttr = struct {100        values: []const Type,101        context: *const anyopaque,102103        pub fn getValues(self: *const TypeListAttr) []const Type {104            return self.values;105        }106    };107108    pub const ArrayAttr = struct {109        values: []const Attribute,110        context: *const anyopaque,111112        pub fn getValues(self: *const ArrayAttr) []const Attribute {113            return self.values;114        }115    };116117    pub fn attrIdFromInt(id: u32) AttrID {118        return @fromBackingInt(@intCast(id));119    }120121    pub fn isa(self: Attribute, comptime attr_id: AttrID) bool {122        return self.attr_id == attr_id;123    }124125    pub fn eql(self: Attribute, other: Attribute) bool {126        if (self.attr_id != other.attr_id) return false;127        if (self.impl == other.impl) return true;128        if (self.getInterface(interfaces.AttributeEqualInterface)) |vtable| {129            return vtable.eql(self.impl, other.impl);130        }131        return false;132    }133134    pub fn getInterface(self: Attribute, comptime IFace: type) ?*const IFace.VTable {135        if (self.abstract.getInterface(IFace.id)) |iface| {136            return @ptrCast(@alignCast(iface));137        }138        return null;139    }140141    pub fn InterfaceHandle(comptime IFace: type) type {142        return struct {143            attr: Attribute,144            vtable: *const IFace.VTable,145146            fn returnType(comptime fn_ptr_type: type) type {147                const ptr_info = @typeInfo(fn_ptr_type);148                const fn_type = switch (ptr_info) {149                    .pointer => |p| p.child,150                    else => @compileError("expected interface vtable field to be a function pointer"),151                };152                const fn_info = switch (@typeInfo(fn_type)) {153                    .@"fn" => |f| f,154                    else => @compileError("expected interface vtable field to be a function pointer"),155                };156                return fn_info.return_type orelse @compileError("generic interface vtable methods are not supported");157            }158159            fn methodFnPtrType(comptime method: std.meta.FieldEnum(IFace.VTable)) type {160                const dummy: IFace.VTable = undefined;161                return @TypeOf(@field(dummy, @tagName(method)));162            }163164            pub inline fn call(165                self: @This(),166                comptime method: std.meta.FieldEnum(IFace.VTable),167                args: anytype,168            ) returnType(methodFnPtrType(method)) {169                const fn_ptr = @field(self.vtable, @tagName(method));170                return @call(.auto, fn_ptr, .{self.attr.impl} ++ args);171            }172        };173    }174175    pub fn interface(self: Attribute, comptime IFace: type) ?InterfaceHandle(IFace) {176        const vtable = self.getInterface(IFace) orelse return null;177        return .{ .attr = self, .vtable = vtable };178    }179180    pub fn getAbstractAttribute(self: Attribute) *const interfaces.AbstractAttribute {181        return self.abstract;182    }183184    pub fn hasStorageType(self: Attribute, comptime T: type) bool {185        return storageTypeMatchesName(T, self.abstract.name);186    }187188    pub fn cast(self: Attribute, comptime T: type) ?*const T {189        if (!self.hasStorageType(T)) return null;190        return @ptrCast(@alignCast(self.impl));191    }192193    pub fn format(self: Attribute, writer: *std.Io.Writer) std.Io.Writer.Error!void {194        if (self.getInterface(interfaces.AttributePrintInterface)) |vtable| {195            return vtable.print(self.impl, writer);196        }197198        if (self.abstract.name.len > 0) {199            try writer.print("#attr<{s}>", .{self.abstract.name});200        } else {201            try writer.print("#attr<{d}>", .{@backingInt(self.attr_id)});202        }203    }204};

1pub const Attribute = ir.Attribute;