tiny.choir.ir.dialects.opSpec

1pub const opSpec = struct {2    pub const Options = struct {3        traits: interfaces.OperationTraits = .{},4        attrs: []const []const u8 = &.{},5        required_attrs: []const []const u8 = &.{},6        attribute_specs: []const AttributeSpec = &.{},7        operand_segments: ?interfaces.OperationSegmentSpec = null,8        result_segments: ?interfaces.OperationSegmentSpec = null,9        operand_types: []const interfaces.OperationTypeConstraint = &.{},10        result_types: []const interfaces.OperationTypeConstraint = &.{},11        properties: ?interfaces.OperationPropertiesModel = null,12        interfaces: []const interfaces.InterfaceEntry = &.{},13        dynamic_traits: []const OperationTraitSpec = &.{},14    };1516    pub fn dialect(comptime Target: type) type {17        const Names = namesFor(Target);18        return struct {19            pub fn name(comptime mnemonic: []const u8) []const u8 {20                return Names.name(mnemonic);21            }2223            pub fn state(comptime OpType: type, loc: Location) Operation.State {24                return Names.state(OpType, loc);25            }2627            pub fn define(comptime spec: anytype) OperationSpec {28                comptime validateDecl(@TypeOf(spec), "mnemonic");29                return shapedWithLayout(Names.name(@field(spec, "mnemonic")), shapeFromDecl(spec), layoutFromDecl(spec), optionsFromDecl(spec));30            }3132            pub fn leaf(comptime spec: anytype) OperationSpec {33                comptime validateDecl(@TypeOf(spec), "mnemonic");34                return shapedWithLayout(Names.name(@field(spec, "mnemonic")), leafShapeFromDecl(spec), layoutFromDecl(spec), optionsFromDecl(spec));35            }3637            pub fn terminator(comptime spec: anytype) OperationSpec {38                comptime validateDecl(@TypeOf(spec), "mnemonic");39                return shapedWithLayout(Names.name(@field(spec, "mnemonic")), terminatorShapeFromDecl(spec), layoutFromDecl(spec), terminatorOptionsFromDecl(spec));40            }41        };42    }4344    pub fn define(comptime spec: anytype) OperationSpec {45        comptime validateDecl(@TypeOf(spec), "name");46        return shapedWithLayout(@field(spec, "name"), shapeFromDecl(spec), layoutFromDecl(spec), optionsFromDecl(spec));47    }4849    pub fn terminator(comptime spec: anytype) OperationSpec {50        comptime validateDecl(@TypeOf(spec), "name");51        return shapedWithLayout(@field(spec, "name"), terminatorShapeFromDecl(spec), layoutFromDecl(spec), terminatorOptionsFromDecl(spec));52    }5354    pub fn shaped(comptime full_name: []const u8, comptime op_shape: interfaces.OperationShape, comptime options: Options) OperationSpec {55        return shapedWithLayout(full_name, op_shape, .{}, options);56    }5758    pub fn dynamicTraits(comptime values: anytype) []const OperationTraitSpec {59        return asSlice(OperationTraitSpec, values, "dynamic_traits");60    }6162    pub fn verifier(comptime verify_fn: *const fn (op_ptr: *const anyopaque) anyerror!void) interfaces.InterfaceEntry {63        return VerifyOpInterface.entryFor(verify_fn);64    }6566    fn shapedWithLayout(comptime full_name: []const u8, comptime op_shape: interfaces.OperationShape, comptime op_layout: OperationLayout, comptime options: Options) OperationSpec {67        if (full_name.len == 0) @compileError("operation name cannot be empty");68        validateLayout(op_shape, op_layout);69        return .{70            .name = full_name,71            .shape = op_shape,72            .operand_names = op_layout.operands,73            .result_names = op_layout.results,74            .region_names = op_layout.regions,75            .successor_names = op_layout.successors,76            .traits = options.traits,77            .inherent_attribute_names = attributeNamesWithRequired(options.attrs, options.required_attrs),78            .required_attribute_names = options.required_attrs,79            .attribute_specs = attributeSpecsWithNames(options.attribute_specs, attributeNamesWithRequired(options.attrs, options.required_attrs)),80            .operand_segments = options.operand_segments,81            .result_segments = options.result_segments,82            .operand_type_constraints = options.operand_types,83            .result_type_constraints = options.result_types,84            .properties_model = options.properties,85            .interfaces = options.interfaces,86            .dynamic_traits = options.dynamic_traits,87        };88    }8990    fn layoutFromDecl(comptime spec: anytype) OperationLayout {91        return .{92            .operands = layoutField(spec, "operands", "operand_names"),93            .results = layoutField(spec, "results", "result_names"),94            .regions = layoutField(spec, "regions", "region_names"),95            .successors = layoutField(spec, "successors", "successor_names"),96        };97    }9899    fn shapeFromDecl(comptime spec: anytype) interfaces.OperationShape {100        const Spec = @TypeOf(spec);101        if (comptime @hasField(Spec, "shape")) {102            if (@hasField(Spec, "operands")) @compileError("operation declaration cannot specify both shape and operands");103            if (@hasField(Spec, "results")) @compileError("operation declaration cannot specify both shape and results");104            if (@hasField(Spec, "regions")) @compileError("operation declaration cannot specify both shape and regions");105            if (@hasField(Spec, "successors")) @compileError("operation declaration cannot specify both shape and successors");106            return shapeFromValue(@field(spec, "shape"));107        }108        return .{109            .operands = shapeField(spec, "operands"),110            .results = shapeField(spec, "results"),111            .regions = shapeField(spec, "regions"),112            .successors = shapeField(spec, "successors"),113        };114    }115116    fn terminatorShapeFromDecl(comptime spec: anytype) interfaces.OperationShape {117        const Spec = @TypeOf(spec);118        if (@hasField(Spec, "shape")) @compileError("terminator operation declaration cannot specify shape");119        return .{120            .operands = shapeField(spec, "operands"),121            .results = shapeFieldOrExact(spec, "results", 0),122            .regions = shapeFieldOrExact(spec, "regions", 0),123            .successors = shapeFieldOrExact(spec, "successors", 0),124        };125    }126127    fn shapeFromValue(comptime value: anytype) interfaces.OperationShape {128        const Value = @TypeOf(value);129        if (Value == interfaces.OperationShape) return value;130        return shape.of(value);131    }132133    fn leafShapeFromDecl(comptime spec: anytype) interfaces.OperationShape {134        const Spec = @TypeOf(spec);135        if (@hasField(Spec, "shape")) @compileError("leaf operation declaration cannot specify shape");136        if (@hasField(Spec, "regions")) @compileError("leaf operation declaration cannot specify regions");137        if (@hasField(Spec, "successors")) @compileError("leaf operation declaration cannot specify successors");138        return .{139            .operands = shapeField(spec, "operands"),140            .results = shapeField(spec, "results"),141            .regions = interfaces.CountRange.exactly(0),142            .successors = interfaces.CountRange.exactly(0),143        };144    }145146    fn shapeField(comptime spec: anytype, comptime name: []const u8) interfaces.CountRange {147        if (comptime @hasField(@TypeOf(spec), name)) return shape.rangeFrom(@field(spec, name));148        return .{};149    }150151    fn layoutField(comptime spec: anytype, comptime shape_name: []const u8, comptime names_name: []const u8) []const []const u8 {152        const inferred = if (comptime @hasField(@TypeOf(spec), shape_name))153            componentNamesFromValue(@field(spec, shape_name), shape_name)154        else155            &.{};156        if (comptime @hasField(@TypeOf(spec), names_name)) {157            const explicit = componentNamesFromValue(@field(spec, names_name), names_name);158            if (inferred.len != 0) {159                @compileError("operation declaration cannot specify both named " ++ shape_name ++ " and " ++ names_name);160            }161            return explicit;162        }163        return inferred;164    }165166    fn validateLayout(comptime op_shape: interfaces.OperationShape, comptime op_layout: OperationLayout) void {167        validateLayoutRange(op_shape.operands, op_layout.operands, "operand");168        validateLayoutRange(op_shape.results, op_layout.results, "result");169        validateLayoutRange(op_shape.regions, op_layout.regions, "region");170        validateLayoutRange(op_shape.successors, op_layout.successors, "successor");171    }172173    fn validateLayoutRange(comptime range: interfaces.CountRange, comptime names: []const []const u8, comptime kind: []const u8) void {174        if (range.max) |max| {175            if (names.len > max) {176                @compileError("operation " ++ kind ++ " names cannot exceed the operation shape maximum");177            }178        }179    }180181    fn shapeFieldOrExact(comptime spec: anytype, comptime name: []const u8, comptime count: usize) interfaces.CountRange {182        if (comptime @hasField(@TypeOf(spec), name)) return shape.rangeFrom(@field(spec, name));183        return interfaces.CountRange.exactly(count);184    }185186    fn optionsFromDecl(comptime spec: anytype) Options {187        const attr_specs = attributeSpecsFromDecl(spec, "attrs");188        const required_attr_specs = attributeSpecsFromDecl(spec, "required_attrs");189        return .{190            .traits = declField(spec, "traits", interfaces.OperationTraits{}),191            .attrs = attributeNamesFromSpecs(attr_specs),192            .required_attrs = attributeNamesFromSpecs(required_attr_specs),193            .attribute_specs = attributeSpecsWithRequired(attr_specs, required_attr_specs),194            .operand_segments = segmentDecl(spec, "operand_segments"),195            .result_segments = segmentDecl(spec, "result_segments"),196            .operand_types = declSlice(interfaces.OperationTypeConstraint, spec, "operand_types"),197            .result_types = declSlice(interfaces.OperationTypeConstraint, spec, "result_types"),198            .properties = declField(spec, "properties", @as(?interfaces.OperationPropertiesModel, null)),199            .interfaces = declSlice(interfaces.InterfaceEntry, spec, "interfaces"),200            .dynamic_traits = if (comptime @hasField(@TypeOf(spec), "dynamic_traits")) dynamicTraits(@field(spec, "dynamic_traits")) else &.{},201        };202    }203204    fn terminatorOptionsFromDecl(comptime spec: anytype) Options {205        return optionsWithDynamicTrait(optionsFromDecl(spec), trait(core_traits.Terminator));206    }207208    fn declField(comptime spec: anytype, comptime name: []const u8, comptime default: anytype) @TypeOf(default) {209        if (comptime @hasField(@TypeOf(spec), name)) return @field(spec, name);210        return default;211    }212213    fn declSlice(comptime Element: type, comptime spec: anytype, comptime name: []const u8) []const Element {214        if (comptime !@hasField(@TypeOf(spec), name)) return &.{};215        return asSlice(Element, @field(spec, name), name);216    }217218    fn segmentDecl(comptime spec: anytype, comptime name: []const u8) ?interfaces.OperationSegmentSpec {219        if (comptime !@hasField(@TypeOf(spec), name)) return null;220        const value = @field(spec, name);221        if (@TypeOf(value) != interfaces.OperationSegmentSpec) {222            @compileError("operation declaration field " ++ name ++ " must be an OperationSegmentSpec");223        }224        return value;225    }226227    fn asSlice(comptime Element: type, comptime values: anytype, comptime name: []const u8) []const Element {228        const Values = @TypeOf(values);229        if (Values == []const Element) return values;230        switch (@typeInfo(Values)) {231            .pointer => |pointer_info| {232                switch (pointer_info.size) {233                    .one => switch (@typeInfo(pointer_info.child)) {234                        .array => |array_info| {235                            const typed = comptime blk: {236                                var out: [array_info.len]Element = undefined;237                                for (values.*, 0..) |value, index| {238                                    out[index] = asElement(Element, value);239                                }240                                break :blk out;241                            };242                            return &typed;243                        },244                        .@"struct" => |struct_info| {245                            if (!struct_info.is_tuple) @compileError("operation declaration field " ++ name ++ " must be a comptime slice, array, or tuple");246                            const typed = comptime blk: {247                                var out: [struct_info.field_names.len]Element = undefined;248                                for (struct_info.field_names, 0..) |field_name, index| {249                                    out[index] = asElement(Element, @field(values.*, field_name));250                                }251                                break :blk out;252                            };253                            return &typed;254                        },255                        else => @compileError("operation declaration field " ++ name ++ " must be a comptime slice or array pointer"),256                    },257                    .slice => {258                        const typed = comptime blk: {259                            var out: [values.len]Element = undefined;260                            for (values, 0..) |value, index| {261                                out[index] = asElement(Element, value);262                            }263                            break :blk out;264                        };265                        return &typed;266                    },267                    else => @compileError("operation declaration field " ++ name ++ " must be a comptime slice or array pointer"),268                }269            },270            .array => |array_info| {271                const typed = comptime blk: {272                    var out: [array_info.len]Element = undefined;273                    for (values, 0..) |value, index| {274                        out[index] = asElement(Element, value);275                    }276                    break :blk out;277                };278                return &typed;279            },280            .@"struct" => |struct_info| {281                if (!struct_info.is_tuple) @compileError("operation declaration field " ++ name ++ " must be a comptime slice, array, or tuple");282                const typed = comptime blk: {283                    var out: [struct_info.field_names.len]Element = undefined;284                    for (struct_info.field_names, 0..) |field_name, index| {285                        out[index] = asElement(Element, @field(values, field_name));286                    }287                    break :blk out;288                };289                return &typed;290            },291            else => @compileError("operation declaration field " ++ name ++ " must be a comptime slice or array pointer"),292        }293    }294295    fn asElement(comptime Element: type, comptime value: anytype) Element {296        const Value = @TypeOf(value);297        if (Element == OperationTraitSpec and Value == type) return trait(value);298        if (Value == Element) return value;299        return switch (@typeInfo(Element)) {300            .@"struct" => |element_info| blk: {301                var out: Element = undefined;302                for (element_info.field_names) |field_name| {303                    @field(out, field_name) = @field(value, field_name);304                }305                break :blk out;306            },307            else => value,308        };309    }310311    fn optionsWithDynamicTrait(comptime options: Options, comptime trait_spec: OperationTraitSpec) Options {312        return .{313            .traits = options.traits.merge(trait_spec.traits),314            .attrs = options.attrs,315            .required_attrs = options.required_attrs,316            .attribute_specs = options.attribute_specs,317            .operand_segments = options.operand_segments,318            .result_segments = options.result_segments,319            .operand_types = options.operand_types,320            .result_types = options.result_types,321            .properties = options.properties,322            .interfaces = options.interfaces,323            .dynamic_traits = dynamicTraitsWith(options.dynamic_traits, trait_spec),324        };325    }326327    fn dynamicTraitsWith(comptime dynamic_traits: []const OperationTraitSpec, comptime trait_spec: OperationTraitSpec) []const OperationTraitSpec {328        for (dynamic_traits) |existing| {329            if (existing.id == trait_spec.id) @compileError("operation dynamic trait is duplicated");330        }331        const values = comptime blk: {332            var out: [dynamic_traits.len + 1]OperationTraitSpec = undefined;333            for (dynamic_traits, 0..) |existing, index| {334                out[index] = existing;335            }336            out[dynamic_traits.len] = trait_spec;337            break :blk out;338        };339        return &values;340    }341342    fn validateDecl(comptime Spec: type, comptime name_field: []const u8) void {343        switch (@typeInfo(Spec)) {344            .@"struct" => |struct_info| {345                if (!@hasField(Spec, name_field)) @compileError("operation declaration must declare " ++ name_field);346                inline for (struct_info.field_names) |field_name| {347                    if (!isDeclField(field_name, name_field)) {348                        @compileError("unknown operation declaration field: " ++ field_name);349                    }350                }351            },352            else => @compileError("operation declaration must be a struct literal"),353        }354    }355356    fn isDeclField(comptime field_name: []const u8, comptime name_field: []const u8) bool {357        return std.mem.eql(u8, field_name, name_field) or358            std.mem.eql(u8, field_name, "shape") or359            std.mem.eql(u8, field_name, "operands") or360            std.mem.eql(u8, field_name, "operand_names") or361            std.mem.eql(u8, field_name, "results") or362            std.mem.eql(u8, field_name, "result_names") or363            std.mem.eql(u8, field_name, "regions") or364            std.mem.eql(u8, field_name, "region_names") or365            std.mem.eql(u8, field_name, "successors") or366            std.mem.eql(u8, field_name, "successor_names") or367            std.mem.eql(u8, field_name, "traits") or368            std.mem.eql(u8, field_name, "attrs") or369            std.mem.eql(u8, field_name, "required_attrs") or370            std.mem.eql(u8, field_name, "operand_segments") or371            std.mem.eql(u8, field_name, "result_segments") or372            std.mem.eql(u8, field_name, "operand_types") or373            std.mem.eql(u8, field_name, "result_types") or374            std.mem.eql(u8, field_name, "properties") or375            std.mem.eql(u8, field_name, "interfaces") or376            std.mem.eql(u8, field_name, "dynamic_traits");377    }378379    fn namesFor(comptime Target: type) type {380        if (comptime isDialectType(Target)) return operationNames(Target);381        if (comptime isOperationNamesType(Target)) return Target;382        @compileError("opSpec.dialect expects a dialect type or operationNames result");383    }384385    fn isDialectType(comptime Target: type) bool {386        if (!@hasDecl(Target, "name")) return false;387        return switch (@typeInfo(@TypeOf(@field(Target, "name")))) {388            .pointer => true,389            else => false,390        };391    }392393    fn isOperationNamesType(comptime Target: type) bool {394        if (!@hasDecl(Target, "name")) return false;395        if (!@hasDecl(Target, "state")) return false;396        return switch (@typeInfo(@TypeOf(@field(Target, "name")))) {397            .@"fn" => true,398            else => false,399        };400    }401};

1pub const opSpec = spec.opSpec;