tiny.choir.ir.dialects.operationTemplate

1pub const operationTemplate = struct {2    pub const FoldFn = *const fn (3        op: *const anyopaque,4        results: *interfaces.FoldResults,5    ) anyerror!void;67    pub const FixedResultTypeFn = *const fn (ctx: *Context) anyerror!Type;89    pub fn dialect(comptime DialectType: type) type {10        return struct {11            pub fn binarySameType(12                comptime mnemonic: []const u8,13                comptime options: opSpec.Options,14            ) type {15                return operationTemplate.binarySameType(DialectType, mnemonic, options);16            }1718            pub fn binarySameTypeFold(19                comptime mnemonic: []const u8,20                comptime options: opSpec.Options,21                comptime fold_fn: FoldFn,22            ) type {23                return operationTemplate.binarySameTypeFold(DialectType, mnemonic, options, fold_fn);24            }2526            pub fn binaryFixedResult(27                comptime mnemonic: []const u8,28                comptime options: opSpec.Options,29                comptime result_type_fn: FixedResultTypeFn,30            ) type {31                return operationTemplate.binaryFixedResult(DialectType, mnemonic, options, result_type_fn);32            }3334            pub fn unarySameType(35                comptime mnemonic: []const u8,36                comptime options: opSpec.Options,37            ) type {38                return operationTemplate.unarySameType(DialectType, mnemonic, options);39            }4041            pub fn unarySameTypeFold(42                comptime mnemonic: []const u8,43                comptime options: opSpec.Options,44                comptime fold_fn: FoldFn,45            ) type {46                return operationTemplate.unarySameTypeFold(DialectType, mnemonic, options, fold_fn);47            }4849            pub fn unaryFixedResult(50                comptime mnemonic: []const u8,51                comptime options: opSpec.Options,52                comptime result_type_fn: FixedResultTypeFn,53            ) type {54                return operationTemplate.unaryFixedResult(DialectType, mnemonic, options, result_type_fn);55            }5657            pub fn unarySameTypeStringAttr(58                comptime mnemonic: []const u8,59                comptime attr_name: []const u8,60                comptime attr_value: []const u8,61                comptime options: opSpec.Options,62            ) type {63                return operationTemplate.unarySameTypeStringAttr(DialectType, mnemonic, attr_name, attr_value, options);64            }6566            pub fn unaryExplicitTypeFold(67                comptime mnemonic: []const u8,68                comptime options: opSpec.Options,69                comptime fold_fn: FoldFn,70            ) type {71                return operationTemplate.unaryExplicitTypeFold(DialectType, mnemonic, options, fold_fn);72            }7374            pub fn unaryExplicitType(75                comptime mnemonic: []const u8,76                comptime options: opSpec.Options,77            ) type {78                return operationTemplate.unaryExplicitType(DialectType, mnemonic, options);79            }8081            pub fn unaryNoResult(82                comptime mnemonic: []const u8,83                comptime options: opSpec.Options,84            ) type {85                return operationTemplate.unaryNoResult(DialectType, mnemonic, options);86            }8788            pub fn ternarySameType(89                comptime mnemonic: []const u8,90                comptime options: opSpec.Options,91            ) type {92                return operationTemplate.ternarySameType(DialectType, mnemonic, options);93            }9495            pub fn ternarySameTypeFold(96                comptime mnemonic: []const u8,97                comptime options: opSpec.Options,98                comptime fold_fn: FoldFn,99            ) type {100                return operationTemplate.ternarySameTypeFold(DialectType, mnemonic, options, fold_fn);101            }102103            pub fn selectSameType(104                comptime mnemonic: []const u8,105                comptime options: opSpec.Options,106            ) type {107                return operationTemplate.selectSameType(DialectType, mnemonic, options);108            }109110            pub fn selectSameTypeFold(111                comptime mnemonic: []const u8,112                comptime options: opSpec.Options,113                comptime fold_fn: FoldFn,114            ) type {115                return operationTemplate.selectSameTypeFold(DialectType, mnemonic, options, fold_fn);116            }117118            pub fn explicitLeaf(119                comptime OpType: type,120                comptime spec: anytype,121            ) type {122                return operationTemplate.explicitLeaf(DialectType, OpType, spec);123            }124125            pub fn explicit(126                comptime OpType: type,127                comptime spec: anytype,128            ) type {129                return operationTemplate.explicit(DialectType, OpType, spec);130            }131132            pub fn explicitTerminator(133                comptime OpType: type,134                comptime spec: anytype,135            ) type {136                return operationTemplate.explicitTerminator(DialectType, OpType, spec);137            }138        };139    }140141    pub fn binarySameType(142        comptime DialectType: type,143        comptime mnemonic: []const u8,144        comptime options: opSpec.Options,145    ) type {146        return binarySameTypeImpl(DialectType, mnemonic, options, null);147    }148149    pub fn binarySameTypeFold(150        comptime DialectType: type,151        comptime mnemonic: []const u8,152        comptime options: opSpec.Options,153        comptime fold_fn: FoldFn,154    ) type {155        return binarySameTypeImpl(DialectType, mnemonic, options, fold_fn);156    }157158    pub fn binaryFixedResult(159        comptime DialectType: type,160        comptime mnemonic: []const u8,161        comptime options: opSpec.Options,162        comptime result_type_fn: FixedResultTypeFn,163    ) type {164        return binaryFixedResultImpl(DialectType, mnemonic, options, result_type_fn);165    }166167    pub fn unarySameType(168        comptime DialectType: type,169        comptime mnemonic: []const u8,170        comptime options: opSpec.Options,171    ) type {172        return unarySameTypeImpl(DialectType, mnemonic, options, null);173    }174175    pub fn unarySameTypeFold(176        comptime DialectType: type,177        comptime mnemonic: []const u8,178        comptime options: opSpec.Options,179        comptime fold_fn: FoldFn,180    ) type {181        return unarySameTypeImpl(DialectType, mnemonic, options, fold_fn);182    }183184    pub fn unaryFixedResult(185        comptime DialectType: type,186        comptime mnemonic: []const u8,187        comptime options: opSpec.Options,188        comptime result_type_fn: FixedResultTypeFn,189    ) type {190        return unaryFixedResultImpl(DialectType, mnemonic, options, result_type_fn);191    }192193    pub fn unarySameTypeStringAttr(194        comptime DialectType: type,195        comptime mnemonic: []const u8,196        comptime attr_name: []const u8,197        comptime attr_value: []const u8,198        comptime options: opSpec.Options,199    ) type {200        return unarySameTypeStringAttrImpl(DialectType, mnemonic, attr_name, attr_value, options);201    }202203    pub fn unaryExplicitTypeFold(204        comptime DialectType: type,205        comptime mnemonic: []const u8,206        comptime options: opSpec.Options,207        comptime fold_fn: FoldFn,208    ) type {209        return unaryExplicitTypeImpl(DialectType, mnemonic, options, fold_fn);210    }211212    pub fn unaryExplicitType(213        comptime DialectType: type,214        comptime mnemonic: []const u8,215        comptime options: opSpec.Options,216    ) type {217        return unaryExplicitTypeImpl(DialectType, mnemonic, options, null);218    }219220    pub fn unaryNoResult(221        comptime DialectType: type,222        comptime mnemonic: []const u8,223        comptime options: opSpec.Options,224    ) type {225        return unaryNoResultImpl(DialectType, mnemonic, options);226    }227228    pub fn ternarySameType(229        comptime DialectType: type,230        comptime mnemonic: []const u8,231        comptime options: opSpec.Options,232    ) type {233        return ternarySameTypeImpl(DialectType, mnemonic, options, null);234    }235236    pub fn ternarySameTypeFold(237        comptime DialectType: type,238        comptime mnemonic: []const u8,239        comptime options: opSpec.Options,240        comptime fold_fn: FoldFn,241    ) type {242        return ternarySameTypeImpl(DialectType, mnemonic, options, fold_fn);243    }244245    pub fn selectSameType(246        comptime DialectType: type,247        comptime mnemonic: []const u8,248        comptime options: opSpec.Options,249    ) type {250        return selectSameTypeImpl(DialectType, mnemonic, options, null);251    }252253    pub fn selectSameTypeFold(254        comptime DialectType: type,255        comptime mnemonic: []const u8,256        comptime options: opSpec.Options,257        comptime fold_fn: FoldFn,258    ) type {259        return selectSameTypeImpl(DialectType, mnemonic, options, fold_fn);260    }261262    pub fn explicitLeaf(263        comptime DialectType: type,264        comptime OpType: type,265        comptime spec: anytype,266    ) type {267        const op_specs = opSpec.dialect(DialectType);268        const generated_spec = op_specs.leaf(spec);269        const accessors = operationAttributeAccessors(OpType, generated_spec);270        return struct {271            pub const operation_spec = generated_spec;272            pub const operation_name = generated_spec.name;273            pub const setI64Attr = accessors.setI64Attr;274            pub const getI64Attr = accessors.getI64Attr;275            pub const setBoolAttr = accessors.setBoolAttr;276            pub const getBoolAttr = accessors.getBoolAttr;277            pub const setStringAttr = accessors.setStringAttr;278            pub const getStringAttr = accessors.getStringAttr;279            pub const setDialectAttrPayload = accessors.setDialectAttrPayload;280            pub const getDialectAttrPayload = accessors.getDialectAttrPayload;281            pub const dialectAttrName = accessors.dialectAttrName;282283            pub fn createLeaf(284                ctx: *Context,285                loc: Location,286                operands: []const *IrValue,287                result_types: []const Type,288            ) !OpType {289                var builder = OperationBuilder.init(ctx);290                var state = Operation.State.init(operation_name, loc);291                state.addOperands(operands);292                state.addTypes(result_types);293                const op = try builder.create(state);294                return .{ .op = op };295            }296297            pub fn getOperand(self: OpType, comptime component_name: []const u8) *IrValue {298                return operand(operation_spec, self.op, component_name);299            }300301            pub fn getOptionalOperand(self: OpType, comptime component_name: []const u8) ?*IrValue {302                return optionalOperand(operation_spec, self.op, component_name);303            }304305            pub fn getOperandSegment(self: OpType, comptime component_name: []const u8) ?[]const *IrValue {306                return operandSegmentValues(operation_spec, self.op, component_name);307            }308309            pub fn getOperandSegmentValue(self: OpType, comptime component_name: []const u8) ?*IrValue {310                return operandSegmentValue(operation_spec, self.op, component_name);311            }312313            pub fn getNamedResult(self: OpType, comptime component_name: []const u8) *IrValue {314                return result(operation_spec, self.op, component_name);315            }316317            pub fn getOptionalResult(self: OpType, comptime component_name: []const u8) ?*IrValue {318                return optionalResult(operation_spec, self.op, component_name);319            }320321            pub fn getResultSegment(self: OpType, comptime component_name: []const u8) ?[]IrValue {322                return resultSegmentValues(operation_spec, self.op, component_name);323            }324325            pub fn getResultSegmentValue(self: OpType, comptime component_name: []const u8) ?*IrValue {326                return resultSegmentValue(operation_spec, self.op, component_name);327            }328329            pub fn getResult(self: OpType) *IrValue {330                if (operation_spec.result_names.len != 1) {331                    @compileError("operationTemplate.explicitLeaf getResult requires exactly one named result");332                }333                return result(operation_spec, self.op, operation_spec.result_names[0]);334            }335        };336    }337338    pub fn explicit(339        comptime DialectType: type,340        comptime OpType: type,341        comptime spec: anytype,342    ) type {343        const op_specs = opSpec.dialect(DialectType);344        const generated_spec = op_specs.define(spec);345        const accessors = operationAttributeAccessors(OpType, generated_spec);346        return struct {347            pub const operation_spec = generated_spec;348            pub const operation_name = generated_spec.name;349            pub const setI64Attr = accessors.setI64Attr;350            pub const getI64Attr = accessors.getI64Attr;351            pub const setBoolAttr = accessors.setBoolAttr;352            pub const getBoolAttr = accessors.getBoolAttr;353            pub const setStringAttr = accessors.setStringAttr;354            pub const getStringAttr = accessors.getStringAttr;355            pub const setDialectAttrPayload = accessors.setDialectAttrPayload;356            pub const getDialectAttrPayload = accessors.getDialectAttrPayload;357            pub const dialectAttrName = accessors.dialectAttrName;358359            pub fn createOperation(360                ctx: *Context,361                loc: Location,362                operands: []const *IrValue,363                result_types: []const Type,364                region_bodies: []const *Region,365                successors: []const *Block,366            ) !OpType {367                var builder = OperationBuilder.init(ctx);368                var state = Operation.State.init(operation_name, loc);369                state.addOperands(operands);370                state.addTypes(result_types);371                state.addRegionBodies(region_bodies);372                state.addSuccessors(successors);373                const op = try builder.create(state);374                return .{ .op = op };375            }376377            pub fn getOperand(self: OpType, comptime component_name: []const u8) *IrValue {378                return operand(operation_spec, self.op, component_name);379            }380381            pub fn getOptionalOperand(self: OpType, comptime component_name: []const u8) ?*IrValue {382                return optionalOperand(operation_spec, self.op, component_name);383            }384385            pub fn getOperandSegment(self: OpType, comptime component_name: []const u8) ?[]const *IrValue {386                return operandSegmentValues(operation_spec, self.op, component_name);387            }388389            pub fn getOperandSegmentValue(self: OpType, comptime component_name: []const u8) ?*IrValue {390                return operandSegmentValue(operation_spec, self.op, component_name);391            }392393            pub fn getNamedResult(self: OpType, comptime component_name: []const u8) *IrValue {394                return result(operation_spec, self.op, component_name);395            }396397            pub fn getOptionalResult(self: OpType, comptime component_name: []const u8) ?*IrValue {398                return optionalResult(operation_spec, self.op, component_name);399            }400401            pub fn getResultSegment(self: OpType, comptime component_name: []const u8) ?[]IrValue {402                return resultSegmentValues(operation_spec, self.op, component_name);403            }404405            pub fn getResultSegmentValue(self: OpType, comptime component_name: []const u8) ?*IrValue {406                return resultSegmentValue(operation_spec, self.op, component_name);407            }408409            pub fn getRegion(self: OpType, comptime component_name: []const u8) *Region {410                return region(operation_spec, self.op, component_name);411            }412413            pub fn getOptionalRegion(self: OpType, comptime component_name: []const u8) ?*Region {414                return optionalRegion(operation_spec, self.op, component_name);415            }416417            pub fn getSuccessor(self: OpType, comptime component_name: []const u8) *Block {418                return successor(operation_spec, self.op, component_name);419            }420421            pub fn getOptionalSuccessor(self: OpType, comptime component_name: []const u8) ?*Block {422                return optionalSuccessor(operation_spec, self.op, component_name);423            }424        };425    }426427    pub fn explicitTerminator(428        comptime DialectType: type,429        comptime OpType: type,430        comptime spec: anytype,431    ) type {432        const op_specs = opSpec.dialect(DialectType);433        const generated_spec = op_specs.terminator(spec);434        const accessors = operationAttributeAccessors(OpType, generated_spec);435        return struct {436            pub const operation_spec = generated_spec;437            pub const operation_name = generated_spec.name;438            pub const setI64Attr = accessors.setI64Attr;439            pub const getI64Attr = accessors.getI64Attr;440            pub const setBoolAttr = accessors.setBoolAttr;441            pub const getBoolAttr = accessors.getBoolAttr;442            pub const setStringAttr = accessors.setStringAttr;443            pub const getStringAttr = accessors.getStringAttr;444            pub const setDialectAttrPayload = accessors.setDialectAttrPayload;445            pub const getDialectAttrPayload = accessors.getDialectAttrPayload;446            pub const dialectAttrName = accessors.dialectAttrName;447448            pub fn createTerminator(449                ctx: *Context,450                loc: Location,451                operands: []const *IrValue,452                successors: []const *Block,453            ) !OpType {454                var builder = OperationBuilder.init(ctx);455                var state = Operation.State.init(operation_name, loc);456                state.addOperands(operands);457                state.addSuccessors(successors);458                const op = try builder.create(state);459                return .{ .op = op };460            }461462            pub fn getOperand(self: OpType, comptime component_name: []const u8) *IrValue {463                return operand(operation_spec, self.op, component_name);464            }465466            pub fn getOptionalOperand(self: OpType, comptime component_name: []const u8) ?*IrValue {467                return optionalOperand(operation_spec, self.op, component_name);468            }469470            pub fn getOperandSegment(self: OpType, comptime component_name: []const u8) ?[]const *IrValue {471                return operandSegmentValues(operation_spec, self.op, component_name);472            }473474            pub fn getOperandSegmentValue(self: OpType, comptime component_name: []const u8) ?*IrValue {475                return operandSegmentValue(operation_spec, self.op, component_name);476            }477478            pub fn getSuccessor(self: OpType, comptime component_name: []const u8) *Block {479                return successor(operation_spec, self.op, component_name);480            }481482            pub fn getOptionalSuccessor(self: OpType, comptime component_name: []const u8) ?*Block {483                return optionalSuccessor(operation_spec, self.op, component_name);484            }485        };486    }487488    fn binarySameTypeImpl(489        comptime DialectType: type,490        comptime mnemonic: []const u8,491        comptime options: opSpec.Options,492        comptime fold_fn: ?FoldFn,493    ) type {494        const generated_spec = opSpec.shaped(operationName(DialectType.name, mnemonic), shape.leaf(2, 1), options);495        if (fold_fn) |fold_impl| {496            return struct {497                op: *Operation,498499                pub const operation_spec = generated_spec;500                pub const operation_name = operation_spec.name;501                pub const fold = fold_impl;502503                pub fn create(ctx: *Context, loc: Location, lhs: *IrValue, rhs: *IrValue) !@This() {504                    var builder = OperationBuilder.init(ctx);505                    var state = Operation.State.init(operation_name, loc);506                    state.addOperands(&.{ lhs, rhs });507                    state.addTypes(&.{lhs.type});508                    const op = try builder.create(state);509                    return .{ .op = op };510                }511512                pub fn getResult(self: *const @This()) *IrValue {513                    return self.op.getResult(0).?;514                }515516                pub fn getLhs(self: @This()) *IrValue {517                    return self.op.getOperand(0).?;518                }519520                pub fn getRhs(self: @This()) *IrValue {521                    return self.op.getOperand(1).?;522                }523            };524        }525526        return struct {527            op: *Operation,528529            pub const operation_spec = generated_spec;530            pub const operation_name = operation_spec.name;531532            pub fn create(ctx: *Context, loc: Location, lhs: *IrValue, rhs: *IrValue) !@This() {533                var builder = OperationBuilder.init(ctx);534                var state = Operation.State.init(operation_name, loc);535                state.addOperands(&.{ lhs, rhs });536                state.addTypes(&.{lhs.type});537                const op = try builder.create(state);538                return .{ .op = op };539            }540541            pub fn getResult(self: *const @This()) *IrValue {542                return self.op.getResult(0).?;543            }544545            pub fn getLhs(self: @This()) *IrValue {546                return self.op.getOperand(0).?;547            }548549            pub fn getRhs(self: @This()) *IrValue {550                return self.op.getOperand(1).?;551            }552        };553    }554555    fn binaryFixedResultImpl(556        comptime DialectType: type,557        comptime mnemonic: []const u8,558        comptime options: opSpec.Options,559        comptime result_type_fn: FixedResultTypeFn,560    ) type {561        const generated_spec = opSpec.shaped(operationName(DialectType.name, mnemonic), shape.leaf(2, 1), options);562        return struct {563            op: *Operation,564565            pub const operation_spec = generated_spec;566            pub const operation_name = operation_spec.name;567568            pub fn create(ctx: *Context, loc: Location, lhs: *IrValue, rhs: *IrValue) !@This() {569                var builder = OperationBuilder.init(ctx);570                var state = Operation.State.init(operation_name, loc);571                state.addOperands(&.{ lhs, rhs });572                state.addTypes(&.{try result_type_fn(ctx)});573                const op = try builder.create(state);574                return .{ .op = op };575            }576577            pub fn getResult(self: *const @This()) *IrValue {578                return self.op.getResult(0).?;579            }580581            pub fn getLhs(self: @This()) *IrValue {582                return self.op.getOperand(0).?;583            }584585            pub fn getRhs(self: @This()) *IrValue {586                return self.op.getOperand(1).?;587            }588        };589    }590591    fn unarySameTypeImpl(592        comptime DialectType: type,593        comptime mnemonic: []const u8,594        comptime options: opSpec.Options,595        comptime fold_fn: ?FoldFn,596    ) type {597        const generated_spec = opSpec.shaped(operationName(DialectType.name, mnemonic), shape.leaf(1, 1), options);598        if (fold_fn) |fold_impl| {599            return struct {600                op: *Operation,601602                pub const operation_spec = generated_spec;603                pub const operation_name = operation_spec.name;604                pub const fold = fold_impl;605606                pub fn create(ctx: *Context, loc: Location, input: *IrValue) !@This() {607                    var builder = OperationBuilder.init(ctx);608                    var state = Operation.State.init(operation_name, loc);609                    state.addOperands(&.{input});610                    state.addTypes(&.{input.type});611                    const op = try builder.create(state);612                    return .{ .op = op };613                }614615                pub fn getResult(self: *const @This()) *IrValue {616                    return self.op.getResult(0).?;617                }618619                pub fn getInput(self: @This()) *IrValue {620                    return self.op.getOperand(0).?;621                }622            };623        }624625        return struct {626            op: *Operation,627628            pub const operation_spec = generated_spec;629            pub const operation_name = operation_spec.name;630631            pub fn create(ctx: *Context, loc: Location, input: *IrValue) !@This() {632                var builder = OperationBuilder.init(ctx);633                var state = Operation.State.init(operation_name, loc);634                state.addOperands(&.{input});635                state.addTypes(&.{input.type});636                const op = try builder.create(state);637                return .{ .op = op };638            }639640            pub fn getResult(self: *const @This()) *IrValue {641                return self.op.getResult(0).?;642            }643644            pub fn getInput(self: @This()) *IrValue {645                return self.op.getOperand(0).?;646            }647        };648    }649650    fn unaryFixedResultImpl(651        comptime DialectType: type,652        comptime mnemonic: []const u8,653        comptime options: opSpec.Options,654        comptime result_type_fn: FixedResultTypeFn,655    ) type {656        const generated_spec = opSpec.shaped(operationName(DialectType.name, mnemonic), shape.leaf(1, 1), options);657        return struct {658            op: *Operation,659660            pub const operation_spec = generated_spec;661            pub const operation_name = operation_spec.name;662663            pub fn create(ctx: *Context, loc: Location, input: *IrValue) !@This() {664                var builder = OperationBuilder.init(ctx);665                var state = Operation.State.init(operation_name, loc);666                state.addOperands(&.{input});667                state.addTypes(&.{try result_type_fn(ctx)});668                const op = try builder.create(state);669                return .{ .op = op };670            }671672            pub fn getResult(self: *const @This()) *IrValue {673                return self.op.getResult(0).?;674            }675676            pub fn getInput(self: @This()) *IrValue {677                return self.op.getOperand(0).?;678            }679        };680    }681682    fn unarySameTypeStringAttrImpl(683        comptime DialectType: type,684        comptime mnemonic: []const u8,685        comptime attr_name: []const u8,686        comptime attr_value: []const u8,687        comptime options: opSpec.Options,688    ) type {689        const generated_options = optionsWithAttr(options, attr_name);690        const generated_spec = opSpec.shaped(operationName(DialectType.name, mnemonic), shape.leaf(1, 1), generated_options);691        return struct {692            op: *Operation,693694            pub const operation_spec = generated_spec;695            pub const operation_name = operation_spec.name;696697            pub fn create(ctx: *Context, loc: Location, input: *IrValue) !@This() {698                var builder = OperationBuilder.init(ctx);699                var state = Operation.State.init(operation_name, loc);700                state.addOperands(&.{input});701                state.addTypes(&.{input.type});702                const op = try builder.create(state);703                try op.setAttr(attr_name, try ctx.getStringAttr(attr_value));704                return .{ .op = op };705            }706707            pub fn getResult(self: *const @This()) *IrValue {708                return self.op.getResult(0).?;709            }710711            pub fn getInput(self: @This()) *IrValue {712                return self.op.getOperand(0).?;713            }714715            pub fn getStringAttr(self: @This()) ?[]const u8 {716                const attr = self.op.getAttrAs(Attribute.StringAttr, attr_name) orelse return null;717                return attr.getValue();718            }719        };720    }721722    fn unaryExplicitTypeImpl(723        comptime DialectType: type,724        comptime mnemonic: []const u8,725        comptime options: opSpec.Options,726        comptime fold_fn: ?FoldFn,727    ) type {728        const generated_spec = opSpec.shaped(operationName(DialectType.name, mnemonic), shape.leaf(1, 1), options);729        if (fold_fn) |fold_impl| {730            return struct {731                op: *Operation,732733                pub const operation_spec = generated_spec;734                pub const operation_name = operation_spec.name;735                pub const fold = fold_impl;736737                pub fn create(ctx: *Context, loc: Location, input: *IrValue, result_type: Type) !@This() {738                    var builder = OperationBuilder.init(ctx);739                    var state = Operation.State.init(operation_name, loc);740                    state.addOperands(&.{input});741                    state.addTypes(&.{result_type});742                    const op = try builder.create(state);743                    return .{ .op = op };744                }745746                pub fn getResult(self: *const @This()) *IrValue {747                    return self.op.getResult(0).?;748                }749750                pub fn getInput(self: @This()) *IrValue {751                    return self.op.getOperand(0).?;752                }753            };754        }755756        return struct {757            op: *Operation,758759            pub const operation_spec = generated_spec;760            pub const operation_name = operation_spec.name;761762            pub fn create(ctx: *Context, loc: Location, input: *IrValue, result_type: Type) !@This() {763                var builder = OperationBuilder.init(ctx);764                var state = Operation.State.init(operation_name, loc);765                state.addOperands(&.{input});766                state.addTypes(&.{result_type});767                const op = try builder.create(state);768                return .{ .op = op };769            }770771            pub fn getResult(self: *const @This()) *IrValue {772                return self.op.getResult(0).?;773            }774775            pub fn getInput(self: @This()) *IrValue {776                return self.op.getOperand(0).?;777            }778        };779    }780781    fn unaryNoResultImpl(782        comptime DialectType: type,783        comptime mnemonic: []const u8,784        comptime options: opSpec.Options,785    ) type {786        const generated_spec = opSpec.shaped(operationName(DialectType.name, mnemonic), shape.leaf(1, 0), options);787        return struct {788            op: *Operation,789790            pub const operation_spec = generated_spec;791            pub const operation_name = operation_spec.name;792793            pub fn create(ctx: *Context, loc: Location, input: *IrValue) !@This() {794                var builder = OperationBuilder.init(ctx);795                var state = Operation.State.init(operation_name, loc);796                state.addOperands(&.{input});797                const op = try builder.create(state);798                return .{ .op = op };799            }800801            pub fn getInput(self: @This()) *IrValue {802                return self.op.getOperand(0).?;803            }804        };805    }806807    fn ternarySameTypeImpl(808        comptime DialectType: type,809        comptime mnemonic: []const u8,810        comptime options: opSpec.Options,811        comptime fold_fn: ?FoldFn,812    ) type {813        const generated_spec = opSpec.shaped(operationName(DialectType.name, mnemonic), shape.leaf(3, 1), options);814        if (fold_fn) |fold_impl| {815            return struct {816                op: *Operation,817818                pub const operation_spec = generated_spec;819                pub const operation_name = operation_spec.name;820                pub const fold = fold_impl;821822                pub fn create(ctx: *Context, loc: Location, a: *IrValue, b: *IrValue, c: *IrValue) !@This() {823                    var builder = OperationBuilder.init(ctx);824                    var state = Operation.State.init(operation_name, loc);825                    state.addOperands(&.{ a, b, c });826                    state.addTypes(&.{a.type});827                    const op = try builder.create(state);828                    return .{ .op = op };829                }830831                pub fn getResult(self: *const @This()) *IrValue {832                    return self.op.getResult(0).?;833                }834835                pub fn getA(self: @This()) *IrValue {836                    return self.op.getOperand(0).?;837                }838839                pub fn getB(self: @This()) *IrValue {840                    return self.op.getOperand(1).?;841                }842843                pub fn getC(self: @This()) *IrValue {844                    return self.op.getOperand(2).?;845                }846            };847        }848849        return struct {850            op: *Operation,851852            pub const operation_spec = generated_spec;853            pub const operation_name = operation_spec.name;854855            pub fn create(ctx: *Context, loc: Location, a: *IrValue, b: *IrValue, c: *IrValue) !@This() {856                var builder = OperationBuilder.init(ctx);857                var state = Operation.State.init(operation_name, loc);858                state.addOperands(&.{ a, b, c });859                state.addTypes(&.{a.type});860                const op = try builder.create(state);861                return .{ .op = op };862            }863864            pub fn getResult(self: *const @This()) *IrValue {865                return self.op.getResult(0).?;866            }867868            pub fn getA(self: @This()) *IrValue {869                return self.op.getOperand(0).?;870            }871872            pub fn getB(self: @This()) *IrValue {873                return self.op.getOperand(1).?;874            }875876            pub fn getC(self: @This()) *IrValue {877                return self.op.getOperand(2).?;878            }879        };880    }881882    fn selectSameTypeImpl(883        comptime DialectType: type,884        comptime mnemonic: []const u8,885        comptime options: opSpec.Options,886        comptime fold_fn: ?FoldFn,887    ) type {888        const generated_spec = opSpec.shaped(operationName(DialectType.name, mnemonic), shape.leaf(3, 1), options);889        if (fold_fn) |fold_impl| {890            return struct {891                op: *Operation,892893                pub const operation_spec = generated_spec;894                pub const operation_name = operation_spec.name;895                pub const fold = fold_impl;896897                pub fn create(ctx: *Context, loc: Location, condition: *IrValue, true_value: *IrValue, false_value: *IrValue) !@This() {898                    var builder = OperationBuilder.init(ctx);899                    var state = Operation.State.init(operation_name, loc);900                    state.addOperands(&.{ condition, true_value, false_value });901                    state.addTypes(&.{true_value.type});902                    const op = try builder.create(state);903                    return .{ .op = op };904                }905906                pub fn getResult(self: *const @This()) *IrValue {907                    return self.op.getResult(0).?;908                }909910                pub fn getCondition(self: @This()) *IrValue {911                    return self.op.getOperand(0).?;912                }913914                pub fn getTrueValue(self: @This()) *IrValue {915                    return self.op.getOperand(1).?;916                }917918                pub fn getFalseValue(self: @This()) *IrValue {919                    return self.op.getOperand(2).?;920                }921            };922        }923924        return struct {925            op: *Operation,926927            pub const operation_spec = generated_spec;928            pub const operation_name = operation_spec.name;929930            pub fn create(ctx: *Context, loc: Location, condition: *IrValue, true_value: *IrValue, false_value: *IrValue) !@This() {931                var builder = OperationBuilder.init(ctx);932                var state = Operation.State.init(operation_name, loc);933                state.addOperands(&.{ condition, true_value, false_value });934                state.addTypes(&.{true_value.type});935                const op = try builder.create(state);936                return .{ .op = op };937            }938939            pub fn getResult(self: *const @This()) *IrValue {940                return self.op.getResult(0).?;941            }942943            pub fn getCondition(self: @This()) *IrValue {944                return self.op.getOperand(0).?;945            }946947            pub fn getTrueValue(self: @This()) *IrValue {948                return self.op.getOperand(1).?;949            }950951            pub fn getFalseValue(self: @This()) *IrValue {952                return self.op.getOperand(2).?;953            }954        };955    }956957    fn optionsWithAttr(comptime options: opSpec.Options, comptime attr_name: []const u8) opSpec.Options {958        return .{959            .traits = options.traits,960            .attrs = attrsWithName(options.attrs, attr_name),961            .required_attrs = attrsWithName(options.required_attrs, attr_name),962            .attribute_specs = attributeSpecsWithNames(options.attribute_specs, attrsWithName(options.attrs, attr_name)),963            .operand_segments = options.operand_segments,964            .result_segments = options.result_segments,965            .operand_types = options.operand_types,966            .result_types = options.result_types,967            .properties = options.properties,968            .interfaces = options.interfaces,969            .dynamic_traits = options.dynamic_traits,970        };971    }972973    fn attrsWithName(comptime attrs: []const []const u8, comptime attr_name: []const u8) []const []const u8 {974        if (attr_name.len == 0) @compileError("operation attribute name cannot be empty");975        for (attrs) |existing| {976            if (std.mem.eql(u8, existing, attr_name)) @compileError("operation attribute name is duplicated");977        }978        const values = comptime blk: {979            var out: [attrs.len + 1][]const u8 = undefined;980            for (attrs, 0..) |attr, index| {981                out[index] = attr;982            }983            out[attrs.len] = attr_name;984            break :blk out;985        };986        return &values;987    }988};

1pub const operationTemplate = spec.operationTemplate;