@zigc/lib 0.17.0-dev.56 → 0.17.0-dev.607

package/std/Build/Step/ObjCopy.zig

@@ -1,92 +1,43 @@
-const std = @import("std");
 const ObjCopy = @This();
 
-const Allocator = std.mem.Allocator;
-const ArenaAllocator = std.heap.ArenaAllocator;
-const File = std.Io.File;
-const InstallDir = std.Build.InstallDir;
+const std = @import("std");
 const Step = std.Build.Step;
-const elf = std.elf;
-const fs = std.fs;
-const sort = std.sort;
-
-pub const base_id: Step.Id = .objcopy;
-
-pub const RawFormat = enum {
-    bin,
-    hex,
-    elf,
-};
-
-pub const Strip = enum {
-    none,
-    debug,
-    debug_and_symbols,
-};
-
-pub const SectionFlags = packed struct {
-    /// add SHF_ALLOC
-    alloc: bool = false,
-
-    /// if section is SHT_NOBITS, set SHT_PROGBITS, otherwise do nothing
-    contents: bool = false,
-
-    /// if section is SHT_NOBITS, set SHT_PROGBITS, otherwise do nothing (same as contents)
-    load: bool = false,
+const Configuration = std.Build.Configuration;
 
-    /// readonly: clear default SHF_WRITE flag
-    readonly: bool = false,
-
-    /// add SHF_EXECINSTR
-    code: bool = false,
+step: Step,
+input_file: std.Build.LazyPath,
+basename: Configuration.OptionalString,
+output_file: Configuration.GeneratedFileIndex,
+debug_file: ?DebugFile,
 
-    /// add SHF_EXCLUDE
-    exclude: bool = false,
+format: ?Format,
+only_section: Configuration.OptionalString,
+pad_to: ?u64,
+strip: Strip,
+compress_debug: bool,
 
-    /// add SHF_X86_64_LARGE. Fatal error if target is not x86_64
-    large: bool = false,
+add_sections: std.ArrayList(AddSection) = .empty,
+update_sections: std.ArrayList(Configuration.Step.ObjCopy.UpdateSection) = .empty,
 
-    /// add SHF_MERGE
-    merge: bool = false,
+pub const base_tag: Step.Tag = .obj_copy;
 
-    /// add SHF_STRINGS
-    strings: bool = false,
-};
+pub const Format = enum { binary, hex, elf };
+pub const Strip = Configuration.Step.ObjCopy.Strip;
+pub const SectionFlags = Configuration.Step.ObjCopy.SectionFlags;
 
 pub const AddSection = struct {
-    section_name: []const u8,
+    section_name: Configuration.String,
     file_path: std.Build.LazyPath,
 };
 
-pub const SetSectionAlignment = struct {
-    section_name: []const u8,
-    alignment: u32,
-};
-
-pub const SetSectionFlags = struct {
-    section_name: []const u8,
-    flags: SectionFlags,
+pub const DebugFile = struct {
+    basename: Configuration.OptionalString,
+    output_file: Configuration.GeneratedFileIndex,
 };
 
-step: Step,
-input_file: std.Build.LazyPath,
-basename: []const u8,
-output_file: std.Build.GeneratedFile,
-output_file_debug: ?std.Build.GeneratedFile,
-
-format: ?RawFormat,
-only_section: ?[]const u8,
-pad_to: ?u64,
-strip: Strip,
-compress_debug: bool,
-
-add_section: ?AddSection,
-set_section_alignment: ?SetSectionAlignment,
-set_section_flags: ?SetSectionFlags,
-
 pub const Options = struct {
     basename: ?[]const u8 = null,
-    format: ?RawFormat = null,
+    format: ?Format = null,
     only_section: ?[]const u8 = null,
     pad_to: ?u64 = null,
 
@@ -96,148 +47,80 @@ pub const Options = struct {
     /// Put the stripped out debug sections in a separate file.
     /// note: the `basename` is baked into the elf file to specify the link to the separate debug file.
     /// see https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html
-    extract_to_separate_file: bool = false,
+    ///
+    /// Makes `getOutputSeparatedDebug` return non-null.
+    separate_debug_file: ?SeparateDebugFile = null,
 
-    add_section: ?AddSection = null,
-    set_section_alignment: ?SetSectionAlignment = null,
-    set_section_flags: ?SetSectionFlags = null,
+    pub const SeparateDebugFile = struct {
+        basename: ?[]const u8,
+    };
 };
 
-pub fn create(
-    owner: *std.Build,
-    input_file: std.Build.LazyPath,
-    options: Options,
-) *ObjCopy {
-    const objcopy = owner.allocator.create(ObjCopy) catch @panic("OOM");
-    objcopy.* = ObjCopy{
-        .step = Step.init(.{
-            .id = base_id,
-            .name = owner.fmt("objcopy {s}", .{input_file.getDisplayName()}),
+pub fn create(owner: *std.Build, input_file: std.Build.LazyPath, options: Options) *ObjCopy {
+    const graph = owner.graph;
+    const wc = &graph.wip_configuration;
+    const oc = graph.create(ObjCopy);
+    oc.* = .{
+        .step = .init(.{
+            .tag = base_tag,
+            .name = owner.fmt("objcopy {f}", .{input_file}),
             .owner = owner,
-            .makeFn = make,
         }),
         .input_file = input_file,
-        .basename = options.basename orelse input_file.getDisplayName(),
-        .output_file = std.Build.GeneratedFile{ .step = &objcopy.step },
-        .output_file_debug = if (options.strip != .none and options.extract_to_separate_file) std.Build.GeneratedFile{ .step = &objcopy.step } else null,
+        .basename = if (options.basename) |s| .init(wc.addString(s) catch @panic("OOM")) else .none,
+        .output_file = graph.addGeneratedFile(&oc.step),
+        .debug_file = if (options.separate_debug_file) |df| .{
+            .basename = if (df.basename) |s| .init(wc.addString(s) catch @panic("OOM")) else .none,
+            .output_file = graph.addGeneratedFile(&oc.step),
+        } else null,
         .format = options.format,
-        .only_section = options.only_section,
+        .only_section = if (options.only_section) |s| .init(wc.addString(s) catch @panic("OOM")) else .none,
         .pad_to = options.pad_to,
         .strip = options.strip,
         .compress_debug = options.compress_debug,
-        .add_section = options.add_section,
-        .set_section_alignment = options.set_section_alignment,
-        .set_section_flags = options.set_section_flags,
     };
-    input_file.addStepDependencies(&objcopy.step);
-    return objcopy;
+    input_file.addStepDependencies(&oc.step);
+    return oc;
 }
 
-pub fn getOutput(objcopy: *const ObjCopy) std.Build.LazyPath {
-    return .{ .generated = .{ .file = &objcopy.output_file } };
+pub const UpdateSectionOptions = struct {
+    alignment: ?std.mem.Alignment = null,
+    flags: SectionFlags = .default,
+};
+
+pub fn updateSection(oc: *ObjCopy, section_name: []const u8, options: UpdateSectionOptions) void {
+    const graph = oc.owner.graph;
+    const arena = graph.arena;
+    const wc = &graph.wip_configuration;
+    oc.update_sections.append(arena, .{
+        .flags = .{
+            .section_flags = options.flags,
+            .alignment = .init(options.alignment),
+        },
+        .section_name = wc.addString(section_name) catch @panic("OOM"),
+    }) catch @panic("OOM");
 }
-pub fn getOutputSeparatedDebug(objcopy: *const ObjCopy) ?std.Build.LazyPath {
-    return if (objcopy.output_file_debug) |*file| .{ .generated = .{ .file = file } } else null;
+
+pub const AddSectionOptions = struct {
+    file_path: std.Build.LazyPath,
+};
+
+pub fn addSection(oc: *ObjCopy, section_name: []const u8, options: AddSectionOptions) void {
+    const graph = oc.owner.graph;
+    const arena = graph.arena;
+    const wc = &graph.wip_configuration;
+    oc.add_sections.append(arena, .{
+        .section_name = wc.addString(section_name) catch @panic("OOM"),
+        .file_path = options.file_path,
+    }) catch @panic("OOM");
+    options.file_path.addStepDependencies(&oc.step);
 }
 
-fn make(step: *Step, options: Step.MakeOptions) !void {
-    const prog_node = options.progress_node;
-    const b = step.owner;
-    const io = b.graph.io;
-    const objcopy: *ObjCopy = @fieldParentPtr("step", step);
-    try step.singleUnchangingWatchInput(objcopy.input_file);
-
-    var man = b.graph.cache.obtain();
-    defer man.deinit();
-
-    const full_src_path = objcopy.input_file.getPath2(b, step);
-    _ = try man.addFile(full_src_path, null);
-    man.hash.addOptionalBytes(objcopy.only_section);
-    man.hash.addOptional(objcopy.pad_to);
-    man.hash.addOptional(objcopy.format);
-    man.hash.add(objcopy.compress_debug);
-    man.hash.add(objcopy.strip);
-    man.hash.add(objcopy.output_file_debug != null);
-
-    if (try step.cacheHit(&man)) {
-        // Cache hit, skip subprocess execution.
-        const digest = man.final();
-        objcopy.output_file.path = try b.cache_root.join(b.allocator, &.{
-            "o", &digest, objcopy.basename,
-        });
-        if (objcopy.output_file_debug) |*file| {
-            file.path = try b.cache_root.join(b.allocator, &.{
-                "o", &digest, b.fmt("{s}.debug", .{objcopy.basename}),
-            });
-        }
-        return;
-    }
-
-    const digest = man.final();
-    const cache_path = "o" ++ fs.path.sep_str ++ digest;
-    const full_dest_path = try b.cache_root.join(b.allocator, &.{ cache_path, objcopy.basename });
-    const full_dest_path_debug = try b.cache_root.join(b.allocator, &.{ cache_path, b.fmt("{s}.debug", .{objcopy.basename}) });
-    b.cache_root.handle.createDirPath(io, cache_path) catch |err| {
-        return step.fail("unable to make path {s}: {s}", .{ cache_path, @errorName(err) });
-    };
+pub fn getOutput(oc: *const ObjCopy) std.Build.LazyPath {
+    return .{ .generated = .{ .index = oc.output_file } };
+}
 
-    var argv = std.array_list.Managed([]const u8).init(b.allocator);
-    try argv.appendSlice(&.{ b.graph.zig_exe, "objcopy" });
-
-    if (objcopy.only_section) |only_section| {
-        try argv.appendSlice(&.{ "-j", only_section });
-    }
-    switch (objcopy.strip) {
-        .none => {},
-        .debug => try argv.appendSlice(&.{"--strip-debug"}),
-        .debug_and_symbols => try argv.appendSlice(&.{"--strip-all"}),
-    }
-    if (objcopy.pad_to) |pad_to| {
-        try argv.appendSlice(&.{ "--pad-to", b.fmt("{d}", .{pad_to}) });
-    }
-    if (objcopy.format) |format| switch (format) {
-        .bin => try argv.appendSlice(&.{ "-O", "binary" }),
-        .hex => try argv.appendSlice(&.{ "-O", "hex" }),
-        .elf => try argv.appendSlice(&.{ "-O", "elf" }),
-    };
-    if (objcopy.compress_debug) {
-        try argv.appendSlice(&.{"--compress-debug-sections"});
-    }
-    if (objcopy.output_file_debug != null) {
-        try argv.appendSlice(&.{b.fmt("--extract-to={s}", .{full_dest_path_debug})});
-    }
-    if (objcopy.add_section) |section| {
-        try argv.append("--add-section");
-        try argv.appendSlice(&.{b.fmt("{s}={s}", .{ section.section_name, section.file_path.getPath2(b, step) })});
-    }
-    if (objcopy.set_section_alignment) |set_align| {
-        try argv.append("--set-section-alignment");
-        try argv.appendSlice(&.{b.fmt("{s}={d}", .{ set_align.section_name, set_align.alignment })});
-    }
-    if (objcopy.set_section_flags) |set_flags| {
-        const f = set_flags.flags;
-        // trailing comma is allowed
-        try argv.append("--set-section-flags");
-        try argv.appendSlice(&.{b.fmt("{s}={s}{s}{s}{s}{s}{s}{s}{s}{s}", .{
-            set_flags.section_name,
-            if (f.alloc) "alloc," else "",
-            if (f.contents) "contents," else "",
-            if (f.load) "load," else "",
-            if (f.readonly) "readonly," else "",
-            if (f.code) "code," else "",
-            if (f.exclude) "exclude," else "",
-            if (f.large) "large," else "",
-            if (f.merge) "merge," else "",
-            if (f.strings) "strings," else "",
-        })});
-    }
-
-    try argv.appendSlice(&.{ full_src_path, full_dest_path });
-
-    try argv.append("--listen=-");
-    _ = try step.evalZigProcess(argv.items, prog_node, false, options.web_server, options.gpa);
-
-    objcopy.output_file.path = full_dest_path;
-    if (objcopy.output_file_debug) |*file| file.path = full_dest_path_debug;
-    try man.writeManifest();
+pub fn getOutputSeparatedDebug(oc: *const ObjCopy) ?std.Build.LazyPath {
+    const df = oc.debug_file orelse return null;
+    return .{ .generated = .{ .index = df.output_file } };
 }

package/std/Build/Step/Options.zig

@@ -1,37 +1,41 @@
 const Options = @This();
+
 const builtin = @import("builtin");
 
 const std = @import("std");
 const Io = std.Io;
 const fs = std.fs;
 const Step = std.Build.Step;
-const GeneratedFile = std.Build.GeneratedFile;
 const LazyPath = std.Build.LazyPath;
-
-pub const base_id: Step.Id = .options;
+const Configuration = std.Build.Configuration;
 
 step: Step,
-generated_file: GeneratedFile,
-
-contents: std.ArrayList(u8),
-args: std.ArrayList(Arg),
+generated_file: Configuration.GeneratedFileIndex,
+contents: std.ArrayList(u8) = .empty,
+args: std.ArrayList(Arg) = .empty,
 encountered_types: std.StringHashMapUnmanaged(void),
 
+pub const base_tag: Step.Tag = .options;
+
+pub const Arg = struct {
+    name: Configuration.String,
+    path: LazyPath,
+};
+
 pub fn create(owner: *std.Build) *Options {
-    const options = owner.allocator.create(Options) catch @panic("OOM");
+    const graph = owner.graph;
+    const arena = graph.arena;
+
+    const options = arena.create(Options) catch @panic("OOM");
     options.* = .{
         .step = .init(.{
-            .id = base_id,
+            .tag = base_tag,
             .name = "options",
             .owner = owner,
-            .makeFn = make,
         }),
-        .generated_file = undefined,
-        .contents = .empty,
-        .args = .empty,
+        .generated_file = graph.addGeneratedFile(&options.step),
         .encountered_types = .empty,
     };
-    options.generated_file = .{ .step = &options.step };
 
     return options;
 }
@@ -410,16 +414,14 @@ fn printStructValue(
     }
 }
 
-/// The value is the path in the cache dir.
-/// Adds a dependency automatically.
-pub fn addOptionPath(
-    options: *Options,
-    name: []const u8,
-    path: LazyPath,
-) void {
-    const arena = options.step.owner.allocator;
+/// The added option has type `[]const u8` and value of the provided path.
+pub fn addOptionPath(options: *Options, name: []const u8, path: LazyPath) void {
+    const graph = options.step.owner.graph;
+    const arena = graph.arena;
+    const wc = &graph.wip_configuration;
+
     options.args.append(arena, .{
-        .name = options.step.owner.dupe(name),
+        .name = try wc.addString(name),
         .path = path.dupe(options.step.owner),
     }) catch @panic("OOM");
     path.addStepDependencies(&options.step);
@@ -434,242 +436,5 @@ pub fn createModule(options: *Options) *std.Build.Module {
 /// Returns the main artifact of this Build Step which is a Zig source file
 /// generated from the key-value pairs of the Options.
 pub fn getOutput(options: *Options) LazyPath {
-    return .{ .generated = .{ .file = &options.generated_file } };
-}
-
-fn make(step: *Step, make_options: Step.MakeOptions) !void {
-    // This step completes so quickly that no progress reporting is necessary.
-    _ = make_options;
-
-    const b = step.owner;
-    const io = b.graph.io;
-    const options: *Options = @fieldParentPtr("step", step);
-
-    for (options.args.items) |item| {
-        options.addOption(
-            []const u8,
-            item.name,
-            item.path.getPath2(b, step),
-        );
-    }
-    if (!step.inputs.populated()) for (options.args.items) |item| {
-        try step.addWatchInput(item.path);
-    };
-
-    const basename = "options.zig";
-
-    // Hash contents to file name.
-    var hash = b.graph.cache.hash;
-    // Random bytes to make unique. Refresh this with new random bytes when
-    // implementation is modified in a non-backwards-compatible way.
-    hash.add(@as(u32, 0xad95e922));
-    hash.addBytes(options.contents.items);
-    const sub_path = "c" ++ fs.path.sep_str ++ hash.final() ++ fs.path.sep_str ++ basename;
-
-    options.generated_file.path = try b.cache_root.join(b.allocator, &.{sub_path});
-
-    // Optimize for the hot path. Stat the file, and if it already exists,
-    // cache hit.
-    if (b.cache_root.handle.access(io, sub_path, .{})) |_| {
-        // This is the hot path, success.
-        step.result_cached = true;
-        return;
-    } else |outer_err| switch (outer_err) {
-        error.FileNotFound => {
-            var atomic_file = b.cache_root.handle.createFileAtomic(io, sub_path, .{
-                .replace = false,
-                .make_path = true,
-            }) catch |err| return step.fail("failed to create temporary path for '{f}{s}': {t}", .{
-                b.cache_root, sub_path, err,
-            });
-            defer atomic_file.deinit(io);
-
-            atomic_file.file.writeStreamingAll(io, options.contents.items) catch |err| {
-                return step.fail("failed to write options to temporary path for '{f}{s}': {t}", .{
-                    b.cache_root, sub_path, err,
-                });
-            };
-
-            atomic_file.link(io) catch |err| switch (err) {
-                error.PathAlreadyExists => {
-                    step.result_cached = true;
-                    return;
-                },
-                else => return step.fail("failed to link temporary file into '{f}{s}': {t}", .{
-                    b.cache_root, sub_path, err,
-                }),
-            };
-        },
-        else => |e| return step.fail("unable to access options file '{f}{s}': {t}", .{
-            b.cache_root, sub_path, e,
-        }),
-    }
-}
-
-const Arg = struct {
-    name: []const u8,
-    path: LazyPath,
-};
-
-test Options {
-    if (builtin.os.tag == .wasi) return error.SkipZigTest;
-
-    const io = std.testing.io;
-
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-
-    const cwd = try std.process.currentPathAlloc(io, std.testing.allocator);
-    defer std.testing.allocator.free(cwd);
-
-    var graph: std.Build.Graph = .{
-        .io = io,
-        .arena = arena.allocator(),
-        .cache = .{
-            .io = io,
-            .gpa = arena.allocator(),
-            .manifest_dir = Io.Dir.cwd(),
-            .cwd = cwd,
-        },
-        .zig_exe = "test",
-        .environ_map = std.process.Environ.Map.init(arena.allocator()),
-        .global_cache_root = .{ .path = "test", .handle = Io.Dir.cwd() },
-        .host = .{
-            .query = .{},
-            .result = try std.zig.system.resolveTargetQuery(io, .{}),
-        },
-        .zig_lib_directory = std.Build.Cache.Directory.cwd(),
-        .time_report = false,
-    };
-
-    var builder = try std.Build.create(
-        &graph,
-        .{ .path = "test", .handle = Io.Dir.cwd() },
-        .{ .path = "test", .handle = Io.Dir.cwd() },
-        &.{},
-    );
-
-    const options = builder.addOptions();
-
-    const KeywordEnum = enum {
-        @"0.8.1",
-    };
-
-    const NormalEnum = enum {
-        foo,
-        bar,
-    };
-
-    const nested_array = [2][2]u16{
-        [2]u16{ 300, 200 },
-        [2]u16{ 300, 200 },
-    };
-    const nested_slice: []const []const u16 = &[_][]const u16{ &nested_array[0], &nested_array[1] };
-
-    const NormalStruct = struct {
-        hello: ?[]const u8,
-        world: bool = true,
-    };
-
-    const NestedStruct = struct {
-        normal_struct: NormalStruct,
-        normal_enum: NormalEnum = .foo,
-    };
-
-    options.addOption(usize, "option1", 1);
-    options.addOption(?usize, "option2", null);
-    options.addOption(?usize, "option3", 3);
-    options.addOption(comptime_int, "option4", 4);
-    options.addOption(comptime_float, "option5", 5.01);
-    options.addOption([]const u8, "string", "zigisthebest");
-    options.addOption(?[]const u8, "optional_string", null);
-    options.addOption([2][2]u16, "nested_array", nested_array);
-    options.addOption([]const []const u16, "nested_slice", nested_slice);
-    options.addOption(KeywordEnum, "keyword_enum", .@"0.8.1");
-    options.addOption(std.SemanticVersion, "semantic_version", try std.SemanticVersion.parse("0.1.2-foo+bar"));
-    options.addOption(NormalEnum, "normal1_enum", NormalEnum.foo);
-    options.addOption(NormalEnum, "normal2_enum", NormalEnum.bar);
-    options.addOption(NormalStruct, "normal1_struct", NormalStruct{
-        .hello = "foo",
-    });
-    options.addOption(NormalStruct, "normal2_struct", NormalStruct{
-        .hello = null,
-        .world = false,
-    });
-    options.addOption(NestedStruct, "nested_struct", NestedStruct{
-        .normal_struct = .{ .hello = "bar" },
-    });
-
-    try std.testing.expectEqualStrings(
-        \\pub const option1: usize = 1;
-        \\pub const option2: ?usize = null;
-        \\pub const option3: ?usize = 3;
-        \\pub const option4: comptime_int = 4;
-        \\pub const option5: comptime_float = 5.01;
-        \\pub const string: []const u8 = "zigisthebest";
-        \\pub const optional_string: ?[]const u8 = null;
-        \\pub const nested_array: [2][2]u16 = [2][2]u16 {
-        \\    [2]u16 {
-        \\        300,
-        \\        200,
-        \\    },
-        \\    [2]u16 {
-        \\        300,
-        \\        200,
-        \\    },
-        \\};
-        \\pub const nested_slice: []const []const u16 = &[_][]const u16 {
-        \\    &[_]u16 {
-        \\        300,
-        \\        200,
-        \\    },
-        \\    &[_]u16 {
-        \\        300,
-        \\        200,
-        \\    },
-        \\};
-        \\pub const @"Build.Step.Options.decltest.Options.KeywordEnum" = enum (u0) {
-        \\    @"0.8.1" = 0,
-        \\};
-        \\pub const keyword_enum: @"Build.Step.Options.decltest.Options.KeywordEnum" = .@"0.8.1";
-        \\pub const semantic_version: @import("std").SemanticVersion = .{
-        \\    .major = 0,
-        \\    .minor = 1,
-        \\    .patch = 2,
-        \\    .pre = "foo",
-        \\    .build = "bar",
-        \\};
-        \\pub const @"Build.Step.Options.decltest.Options.NormalEnum" = enum (u1) {
-        \\    foo = 0,
-        \\    bar = 1,
-        \\};
-        \\pub const normal1_enum: @"Build.Step.Options.decltest.Options.NormalEnum" = .foo;
-        \\pub const normal2_enum: @"Build.Step.Options.decltest.Options.NormalEnum" = .bar;
-        \\pub const @"Build.Step.Options.decltest.Options.NormalStruct" = struct {
-        \\    hello: ?[]const u8,
-        \\    world: bool = true,
-        \\};
-        \\pub const normal1_struct: @"Build.Step.Options.decltest.Options.NormalStruct" = .{
-        \\    .hello = "foo",
-        \\    .world = true,
-        \\};
-        \\pub const normal2_struct: @"Build.Step.Options.decltest.Options.NormalStruct" = .{
-        \\    .hello = null,
-        \\    .world = false,
-        \\};
-        \\pub const @"Build.Step.Options.decltest.Options.NestedStruct" = struct {
-        \\    normal_struct: @"Build.Step.Options.decltest.Options.NormalStruct",
-        \\    normal_enum: @"Build.Step.Options.decltest.Options.NormalEnum" = .foo,
-        \\};
-        \\pub const nested_struct: @"Build.Step.Options.decltest.Options.NestedStruct" = .{
-        \\    .normal_struct = .{
-        \\        .hello = "bar",
-        \\        .world = true,
-        \\    },
-        \\    .normal_enum = .foo,
-        \\};
-        \\
-    , options.contents.items);
-
-    _ = try std.zig.Ast.parse(arena.allocator(), try options.contents.toOwnedSliceSentinel(arena.allocator(), 0), .zig);
+    return .{ .generated = .{ .index = options.generated_file } };
 }