tiny.choir.diagnostics

1pub const CaptureBuffer = struct {2    arena: alloc_arena.Arena,3    diagnostics: std.ArrayListUnmanaged(Diagnostic) = .empty,45    pub fn init(allocator: std.mem.Allocator) CaptureBuffer {6        return .{ .arena = alloc_arena.Arena.init(allocator) };7    }89    pub fn deinit(self: *CaptureBuffer) void {10        self.arena.deinit();11        self.* = undefined;12    }1314    pub fn append(self: *CaptureBuffer, diagnostic: Diagnostic) !void {15        const allocator = self.arena.allocator();16        var copied = diagnostic;17        copied.message = try allocator.dupe(u8, diagnostic.message);18        if (diagnostic.error_name) |name| {19            copied.error_name = try allocator.dupe(u8, name);20        }21        copied.notes = try cloneNotes(allocator, diagnostic.notes);22        copied.metadata = try cloneMetadata(allocator, diagnostic.metadata);23        try self.diagnostics.append(allocator, copied);24    }25};

1pub const CaptureGuard = struct {2    scope: ?*CaptureScope,34    pub fn deinit(self: *CaptureGuard) void {5        if (self.scope) |scope| {6            scope.exit();7            self.scope = null;8        }9    }10};

1pub const CaptureScope = struct {2    engine: *Engine,3    buffer: *CaptureBuffer,4    previous: ?*CaptureScope = null,56    pub fn enter(self: *CaptureScope) CaptureGuard {7        self.previous = active_capture;8        active_capture = self;9        return .{ .scope = self };10    }1112    fn exit(self: *CaptureScope) void {13        std.debug.assert(active_capture == self);14        active_capture = self.previous;15        self.previous = null;16    }17};

1pub const Diagnostic = struct {2    severity: Severity,3    location: ir.Location,4    message: []const u8,5    operation: ?*ir.Operation = null,6    error_name: ?[]const u8 = null,7    notes: []const Note = &.{},8    metadata: []const Metadata = &.{},910    pub fn operationName(self: Diagnostic) ?[]const u8 {11        const op = self.operation orelse return null;12        return op.name.name;13    }14};

1pub const Engine = struct {2    handlers: std.ArrayListUnmanaged(HandlerEntry) = .empty,3    next_id: HandlerId = 0,45    pub const HandlerId = usize;67    const HandlerEntry = struct {8        id: HandlerId,9        handler: Handler,10    };1112    pub fn init() Engine {13        return .{};14    }1516    pub fn deinit(self: *Engine, handler_allocator: std.mem.Allocator) void {17        self.handlers.deinit(handler_allocator);18        self.* = undefined;19    }2021    pub fn registerHandler(22        self: *Engine,23        handler_allocator: std.mem.Allocator,24        handler: Handler,25    ) !HandlerId {26        const id = self.next_id;27        const next_id = std.math.add(HandlerId, id, 1) catch return error.HandlerIdExhausted;28        try self.handlers.append(handler_allocator, .{ .id = id, .handler = handler });29        self.next_id = next_id;30        return id;31    }3233    pub fn eraseHandler(self: *Engine, id: HandlerId) void {34        for (self.handlers.items, 0..) |entry, index| {35            if (entry.id == id) {36                _ = self.handlers.orderedRemove(index);37                return;38            }39        }40    }4142    pub fn emit(43        self: *Engine,44        diagnostic: Diagnostic,45    ) InFlightDiagnostic {46        return .{47            .engine = self,48            .diagnostic = diagnostic,49        };50    }5152    pub fn report(self: *Engine, diagnostic: Diagnostic) !HandlerResult {53        if (active_capture) |scope| {54            if (scope.engine == self) {55                try scope.buffer.append(diagnostic);56                return .consumed;57            }58        }59        return self.reportHandlers(diagnostic);60    }6162    pub fn capture(self: *Engine, buffer: *CaptureBuffer) CaptureScope {63        return .{64            .engine = self,65            .buffer = buffer,66        };67    }6869    pub fn replay(self: *Engine, buffer: *const CaptureBuffer) !HandlerResult {70        var result: HandlerResult = .propagate;71        for (buffer.diagnostics.items) |diagnostic| {72            if (try self.reportHandlers(diagnostic) == .consumed) {73                result = .consumed;74            }75        }76        return result;77    }7879    fn reportHandlers(self: *Engine, diagnostic: Diagnostic) !HandlerResult {80        var index = self.handlers.items.len;81        while (index > 0) {82            index -= 1;83            const handler = self.handlers.items[index].handler;84            if (try handler.handle(handler.context, &diagnostic) == .consumed) {85                return .consumed;86            }87        }88        return .propagate;89    }90};

1pub const Handler = struct {2    context: ?*anyopaque = null,3    handle: *const fn (context: ?*anyopaque, diagnostic: *const Diagnostic) anyerror!HandlerResult,4};

1pub const HandlerResult = enum {2    consumed,3    propagate,4};

1pub const InFlightDiagnostic = struct {2    engine: *Engine,3    diagnostic: Diagnostic,4    notes: std.ArrayListUnmanaged(Note) = .empty,5    metadata: std.ArrayListUnmanaged(Metadata) = .empty,6    notes_copied: bool = false,7    metadata_copied: bool = false,8    emitted: bool = false,9    owned_message: ?[]u8 = null,1011    pub const Error = error{DiagnosticAlreadyEmitted} || std.mem.Allocator.Error;1213    pub fn deinit(self: *InFlightDiagnostic, payload_allocator: std.mem.Allocator) void {14        if (self.owned_message) |message| {15            payload_allocator.free(message);16        }17        self.notes.deinit(payload_allocator);18        self.metadata.deinit(payload_allocator);19        self.* = undefined;20    }2122    pub fn ownMessage(self: *InFlightDiagnostic, message: []u8) void {23        self.owned_message = message;24        self.diagnostic.message = message;25    }2627    pub fn attachNote(28        self: *InFlightDiagnostic,29        payload_allocator: std.mem.Allocator,30        message: []const u8,31    ) Error!void {32        return self.attachNoteAt(payload_allocator, self.diagnostic.location, message);33    }3435    pub fn attachNoteAt(36        self: *InFlightDiagnostic,37        payload_allocator: std.mem.Allocator,38        location: ir.Location,39        message: []const u8,40    ) Error!void {41        try self.requireMutable();42        try self.ensureNotesMutable(payload_allocator);43        try self.notes.append(payload_allocator, .{44            .location = location,45            .message = message,46        });47    }4849    pub fn addMetadata(50        self: *InFlightDiagnostic,51        payload_allocator: std.mem.Allocator,52        name: []const u8,53        value: []const u8,54    ) Error!void {55        try self.requireMutable();56        try self.ensureMetadataMutable(payload_allocator);57        try self.metadata.append(payload_allocator, .{58            .name = name,59            .value = value,60        });61    }6263    pub fn emit(self: *InFlightDiagnostic) !HandlerResult {64        self.emitted = true;65        var diagnostic = self.diagnostic;66        if (self.notes_copied) {67            diagnostic.notes = self.notes.items;68        }69        if (self.metadata_copied) {70            diagnostic.metadata = self.metadata.items;71        }72        return self.engine.report(diagnostic);73    }7475    fn requireMutable(self: *const InFlightDiagnostic) Error!void {76        if (self.emitted) return error.DiagnosticAlreadyEmitted;77    }7879    fn ensureNotesMutable(80        self: *InFlightDiagnostic,81        payload_allocator: std.mem.Allocator,82    ) Error!void {83        if (self.notes_copied) return;84        try self.notes.appendSlice(payload_allocator, self.diagnostic.notes);85        self.notes_copied = true;86    }8788    fn ensureMetadataMutable(89        self: *InFlightDiagnostic,90        payload_allocator: std.mem.Allocator,91    ) Error!void {92        if (self.metadata_copied) return;93        try self.metadata.appendSlice(payload_allocator, self.diagnostic.metadata);94        self.metadata_copied = true;95    }96};

1pub const Metadata = struct {2    name: []const u8,3    value: []const u8,4};

1pub const Note = struct {2    location: ir.Location,3    message: []const u8,4};

1pub const Severity = enum {2    note,3    warning,4    remark,5    err,6};

1pub const VerifierFailure = struct {2    stage: []const u8,3    root: *ir.Operation,4    operation: *ir.Operation,5    location: ir.Location,6    err: anyerror,78    pub fn init(9        stage: []const u8,10        root: *ir.Operation,11        options: ir.VerifyOptions,12        err: anyerror,13    ) VerifierFailure {14        const operation = findFailureOp(root, options) orelse root;15        return .{16            .stage = stage,17            .root = root,18            .operation = operation,19            .location = operation.getLoc(),20            .err = err,21        };22    }2324    pub fn diagnostic(self: *const VerifierFailure) Diagnostic {25        return .{26            .severity = .err,27            .location = self.location,28            .message = "Choir verifier failed",29            .operation = self.operation,30            .error_name = @errorName(self.err),31        };32    }3334    pub fn format(self: *const VerifierFailure, buf: []u8) []const u8 {35        return formatVerifierFailure(buf, self.*);36    }37};

1pub fn BoundInFlightDiagnostic(2    comptime Context: type,3    comptime payloadAllocator: anytype,4) type {5    return struct {6        context: *Context,7        diagnostic: InFlightDiagnostic,89        const Self = @This();10        pub const Error = InFlightDiagnostic.Error;1112        pub fn deinit(self: *Self) void {13            self.diagnostic.deinit(payloadAllocator(self.context));14            self.* = undefined;15        }1617        pub fn ownMessage(self: *Self, message: []u8) void {18            self.diagnostic.ownMessage(message);19        }2021        pub fn attachNote(self: *Self, message: []const u8) Error!void {22            return self.diagnostic.attachNote(payloadAllocator(self.context), message);23        }2425        pub fn attachNoteAt(26            self: *Self,27            location: ir.Location,28            message: []const u8,29        ) Error!void {30            return self.diagnostic.attachNoteAt(31                payloadAllocator(self.context),32                location,33                message,34            );35        }3637        pub fn addMetadata(38            self: *Self,39            name: []const u8,40            value: []const u8,41        ) Error!void {42            return self.diagnostic.addMetadata(43                payloadAllocator(self.context),44                name,45                value,46            );47        }4849        pub fn emit(self: *Self) !HandlerResult {50            return self.diagnostic.emit();51        }52    };53}

1pub fn captureVerifierFailure(2    stage: []const u8,3    root: *ir.Operation,4    options: ir.VerifyOptions,5    err: anyerror,6) VerifierFailure {7    return VerifierFailure.init(stage, root, options, err);8}

1pub fn findFailureOp(root: *ir.Operation, options: ir.VerifyOptions) ?*ir.Operation {2    const shallow = ir.VerifyOptions{3        .check_terminators = options.check_terminators,4        .require_terminators = options.require_terminators,5        .recursive = false,6        .check_use_def = options.check_use_def,7        .check_local_dominance = options.check_local_dominance,8        .check_cfg = options.check_cfg,9        .max_depth = options.max_depth,10    };11    return findFailureOpRecursive(root, shallow);12}

1pub fn formatVerifierFailure(buf: []u8, failure: VerifierFailure) []const u8 {2    var loc_buf: [128]u8 = undefined;3    const loc_str = formatLocation(&loc_buf, failure.location);45    return std.fmt.bufPrint(6        buf,7        "Choir verifier failed ({s}): op={s} {s} error={s}",8        .{ failure.stage, failure.operation.name.name, loc_str, @errorName(failure.err) },9    ) catch "Choir verifier failed";10}

1pub fn operationDiagnostic(2    op: *ir.Operation,3    severity: Severity,4    message: []const u8,5) Diagnostic {6    return .{7        .severity = severity,8        .location = op.getLoc(),9        .message = message,10        .operation = op,11    };12}

1const engine = @import("engine.zig");23pub const Severity = engine.Severity;4pub const Metadata = engine.Metadata;5pub const Note = engine.Note;6pub const Diagnostic = engine.Diagnostic;7pub const operationDiagnostic = engine.operationDiagnostic;8pub const InFlightDiagnostic = engine.InFlightDiagnostic;9pub const BoundInFlightDiagnostic = engine.BoundInFlightDiagnostic;10pub const HandlerResult = engine.HandlerResult;11pub const Handler = engine.Handler;12pub const Engine = engine.Engine;13pub const CaptureBuffer = engine.CaptureBuffer;14pub const CaptureScope = engine.CaptureScope;15pub const CaptureGuard = engine.CaptureGuard;16pub const VerifierFailure = engine.VerifierFailure;17pub const captureVerifierFailure = engine.captureVerifierFailure;18pub const formatVerifierFailure = engine.formatVerifierFailure;19pub const findFailureOp = engine.findFailureOp;

1pub const diagnostics = @import("diagnostics/root.zig");