tiny.choir.Pass

1pub const Pass = struct {2    work_contract: ?subject.work.Contract = null,34    name: []const u8,56    description: []const u8,78    run_fn: ?*const fn (*PassContext) PassResult = null,910    state: ?*anyopaque = null,1112    run_with_state_fn: ?*const fn (?*anyopaque, *PassContext) PassResult = null,1314    state_concurrency: PassStateConcurrency = .exclusive,1516    rerun_policy: PassRerunPolicy = .always,1718    state_clone_fn: ?*const fn (?*anyopaque, std.mem.Allocator) anyerror!?*anyopaque = null,1920    state_deinit_fn: ?*const fn (?*anyopaque, std.mem.Allocator) void = null,2122    mutation_scope: PassMutationScope = .whole_module,2324    dependent_dialects: DependentDialects = &.{},2526    textual_options: ?[]const u8 = null,2728    owns_textual_options: bool = false,2930    pub fn run(self: Pass, ctx: *PassContext) PassResult {31        if (self.run_with_state_fn) |run_with_state| {32            return run_with_state(self.state, ctx);33        }34        if (self.run_fn) |run_pass| {35            return run_pass(ctx);36        }37        return .failure;38    }3940    pub fn readOnly(self: Pass) bool {41        return self.mutation_scope == .read_only;42    }4344    pub fn isolatedMutation(self: Pass) bool {45        return self.mutation_scope == .isolated;46    }4748    pub fn wholeModuleMutation(self: Pass) bool {49        return self.mutation_scope == .whole_module;50    }5152    pub fn parallelStateSafe(self: Pass) bool {53        if (self.state == null) return true;54        if (self.state_concurrency == .shared) return true;55        return self.state_clone_fn != null;56    }5758    pub fn validRerunContract(self: Pass) bool {59        return switch (self.rerun_policy) {60            .always => true,61            .skip_if_unchanged => self.state == null and62                self.run_with_state_fn == null and63                self.run_fn != null,64        };65    }6667    pub fn sameRerunIdentity(self: Pass, previous: Pass) bool {68        if (self.rerun_policy != .skip_if_unchanged) return false;69        if (previous.rerun_policy != .skip_if_unchanged) return false;70        if (!self.validRerunContract() or !previous.validRerunContract()) return false;71        if (self.run_fn != previous.run_fn) return false;72        return std.mem.eql(73            u8,74            self.textual_options orelse "",75            previous.textual_options orelse "",76        );77    }7879    pub fn cloneForParallelTarget(self: Pass, allocator: std.mem.Allocator) anyerror!Pass {80        var cloned = self;81        cloned.owns_textual_options = false;82        if (self.state) |_| {83            if (self.state_clone_fn) |clone_fn| {84                cloned.state = try clone_fn(self.state, allocator);85                return cloned;86            }87            if (self.state_concurrency == .shared) {88                cloned.state_deinit_fn = null;89                return cloned;90            }91            return error.PassStateNotParallel;92        }93        cloned.state_deinit_fn = null;94        return cloned;95    }9697    pub fn deinit(self: *Pass, allocator: std.mem.Allocator) void {98        if (self.state_deinit_fn) |deinit_fn| deinit_fn(self.state, allocator);99        if (self.owns_textual_options) {100            if (self.textual_options) |text| allocator.free(text);101        }102        self.* = undefined;103    }104};

1pub const Pass = passes.Pass;