srctree

/// The file that was loaded with `@embedFile` has changed on disk

/// and has been re-loaded into memory. All Decls that depend on it

/// need to be re-analyzed.

update_embed_file: *Module.EmbedFile,

var embed_file_prog_node = main_progress_node.start("Detect @embedFile updates", comp.embed_file_work_queue.count);

defer embed_file_prog_node.end();

 

comp, embed_file, &embed_file_prog_node, &comp.astgen_wait_group,

.update_embed_file => |embed_file| {

const named_frame = tracy.namedFrame("update_embed_file");

defer named_frame.end();

 

const module = comp.bin_file.options.module.?;

module.updateEmbedFile(embed_file) catch |err| switch (err) {

error.OutOfMemory => return error.OutOfMemory,

error.AnalysisFail => return,

};

},

prog_node: *std.Progress.Node,

var child_prog_node = prog_node.start(embed_file.sub_file_path, 0);

child_prog_node.activate();

defer child_prog_node.end();

 

const mod = comp.bin_file.options.module.?;

mod.detectEmbedFileUpdate(embed_file) catch |err| {

 

const src_loc: Module.SrcLoc = mod.declPtr(embed_file.owner_decl).srcLoc(mod);

 

embed_file.mod.root, embed_file.sub_file_path, @errorName(err),

assert(bytes[@as(usize, @intCast(len))] == ip.indexToKey(sentinel).int.storage.u64);

assert(elems[@as(usize, @intCast(len))] == sentinel);

try ip.string_bytes.ensureUnusedCapacity(gpa, @as(usize, @intCast(len_including_sentinel + 1)));

@as(u8, @intCast(int.storage.u64)),

ip.string_bytes.addManyAsSliceAssumeCapacity(@as(usize, @intCast(len))),

@as(u8, @intCast(int.storage.u64)),

@as(u8, @intCast(ip.indexToKey(sentinel).int.storage.u64)),

const string = if (has_internal_null)

@as(String, @enumFromInt(string_bytes_index))

(try ip.getOrPutTrailingString(gpa, @as(usize, @intCast(len_including_sentinel)))).toString();

const len = @as(usize, @intCast(std.fmt.count(format, args) + 1));

const str_index = @as(u32, @intCast(string_bytes.items.len - len));

/// Represents the contents of a file loaded with `@embedFile`.

/// Relative to the owning package's root_src_dir.

/// Memory is stored in gpa, owned by EmbedFile.

sub_file_path: []const u8,

bytes: [:0]const u8,

/// Package that this file is a part of, managed externally.

mod: *Package.Module,

/// The Decl that was created from the `@embedFile` to own this resource.

/// This is how zig knows what other Decl objects to invalidate if the file

/// changes on disk.

owner_decl: Decl.Index,

 

fn destroy(embed_file: *EmbedFile, mod: *Module) void {

const gpa = mod.gpa;

gpa.free(embed_file.sub_file_path);

gpa.free(embed_file.bytes);

gpa.destroy(embed_file);

}

entry.value_ptr.*.destroy(mod);

pub fn updateEmbedFile(mod: *Module, embed_file: *EmbedFile) SemaError!void {

const tracy = trace(@src());

defer tracy.end();

 

// TODO we can potentially relax this if we store some more information along

// with decl dependency edges

const owner_decl = mod.declPtr(embed_file.owner_decl);

for (owner_decl.dependants.keys()) |dep_index| {

const dep = mod.declPtr(dep_index);

switch (dep.analysis) {

.unreferenced => unreachable,

.in_progress => continue, // already doing analysis, ok

.outdated => continue, // already queued for update

 

.file_failure,

.dependency_failure,

.sema_failure,

.sema_failure_retryable,

.liveness_failure,

.codegen_failure,

.codegen_failure_retryable,

.complete,

=> if (dep.generation != mod.generation) {

try mod.markOutdatedDecl(dep_index);

},

}

}

}

 

pub fn embedFile(mod: *Module, cur_file: *File, import_string: []const u8) !*EmbedFile {

errdefer assert(mod.embed_table.remove(resolved_path));

if (gop.found_existing) return gop.value_ptr.*;

return newEmbedFile(mod, pkg, sub_file_path, resolved_path, &keep_resolved_path, gop);

errdefer assert(mod.embed_table.remove(resolved_path));

if (gop.found_existing) return gop.value_ptr.*;

return newEmbedFile(mod, cur_file.mod, sub_file_path, resolved_path, &keep_resolved_path, gop);

keep_resolved_path: *bool,

) !*EmbedFile {

const size_usize = std.math.cast(usize, actual_stat.size) orelse return error.Overflow;

const bytes = try file.readToEndAllocOptions(gpa, std.math.maxInt(u32), size_usize, 1, 0);

errdefer gpa.free(bytes);

try whole_cache_manifest.addFilePostContents(copied_resolved_path, bytes, stat);

keep_resolved_path.* = true; // It's now owned by embed_table.

.sub_file_path = sub_file_path,

.bytes = bytes,

.mod = pkg,

.owner_decl = undefined, // Set by Sema immediately after this function returns.

return new_file;

}

 

pub fn detectEmbedFileUpdate(mod: *Module, embed_file: *EmbedFile) !void {

var file = try embed_file.mod.root.openFile(embed_file.sub_file_path, .{});

defer file.close();

 

const stat = try file.stat();

 

const unchanged_metadata =

stat.size == embed_file.stat.size and

stat.mtime == embed_file.stat.mtime and

stat.inode == embed_file.stat.inode;

 

if (unchanged_metadata) return;

 

const gpa = mod.gpa;

const size_usize = std.math.cast(usize, stat.size) orelse return error.Overflow;

const bytes = try file.readToEndAllocOptions(gpa, std.math.maxInt(u32), size_usize, 1, 0);

gpa.free(embed_file.bytes);

embed_file.bytes = bytes;

embed_file.stat = .{

.size = stat.size,

.mtime = stat.mtime,

.inode = stat.inode,

};

 

mod.comp.mutex.lock();

defer mod.comp.mutex.unlock();

try mod.comp.work_queue.writeItem(.{ .update_embed_file = embed_file });

var anon_decl = try block.startAnonDecl();

var anon_decl = try block.startAnonDecl();

var anon_decl = try block.startAnonDecl();

const embed_file = mod.embedFile(block.getFileScope(mod), name) catch |err| switch (err) {

var anon_decl = try block.startAnonDecl();

defer anon_decl.deinit();

 

// TODO instead of using `.bytes`, create a new value tag for pointing at

// a `*Module.EmbedFile`. The purpose of this would be:

// - If only the length is read and the bytes are not inspected by comptime code,

// there can be an optimization where the codegen backend does a copy_file_range

// into the final binary, and never loads the data into memory.

// - When a Decl is destroyed, it can free the `*Module.EmbedFile`.

const ty = try mod.arrayType(.{

.len = embed_file.bytes.len,

.sentinel = .zero_u8,

.child = .u8_type,

});

embed_file.owner_decl = try anon_decl.finish(

ty,

(try mod.intern(.{ .aggregate = .{

.ty = ty.toIntern(),

.storage = .{ .bytes = embed_file.bytes },

} })).toValue(),

.none, // default alignment

);

 

return sema.analyzeDeclRef(embed_file.owner_decl);

const repl_help =

\\Commands:

\\ update Detect changes to source files and update output files.

\\ run Execute the output file, if it is an executable or test.

\\ update-and-run Perform an `update` followed by `run`.

\\ help Print this text

\\ exit Quit this repl

\\

;

 

_ = @import("behavior/bugs/3779.zig");

try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", type_name));

try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", ptr_type_name[0..type_name.len]));

const actual_contents = @embedFile("3779_file_to_embed.txt");

try std.testing.expect(std.mem.endsWith(u8, src.file, "3779.zig"));