Commit f708c5fafc5087a2518e0dc7acf986b59673dddd | zig

lib/std/process.zig+1-1

...	...	@@ -46,7 +46,7 @@ pub fn getCwdAlloc(allocator: Allocator) ![]u8 {
46	46	}
47	47	}
48	48
49		test "getCwdAlloc" {
	49	test getCwdAlloc {
50	50	if (builtin.os.tag == .wasi) return error.SkipZigTest;
51	51
52	52	const cwd = try getCwdAlloc(testing.allocator);

src/Autodoc.zig+17-18

...	...	@@ -6,7 +6,7 @@ const Autodoc = @This();
6	6	const Compilation = @import("Compilation.zig");
7	7	const CompilationModule = @import("Module.zig");
8	8	const File = CompilationModule.File;
9		const Module = @import("Package.zig");
	9	const Module = @import("Package.zig").Module;
10	10	const Tokenizer = std.zig.Tokenizer;
11	11	const InternPool = @import("InternPool.zig");
12	12	const Zir = @import("Zir.zig");
...	...	@@ -98,9 +98,8 @@ pub fn generate(cm: *CompilationModule, output_dir: std.fs.Dir) !void {
98	98	}
99	99
100	100	fn generateZirData(self: *Autodoc, output_dir: std.fs.Dir) !void {
101		const root_src_dir = self.comp_module.main_pkg.root_src_directory;
102		const root_src_path = self.comp_module.main_pkg.root_src_path;
103		const joined_src_path = try root_src_dir.join(self.arena, &.{root_src_path});
	101	const root_src_path = self.comp_module.main_mod.root_src_path;
	102	const joined_src_path = try self.comp_module.main_mod.root.joinString(self.arena, root_src_path);
104	103	defer self.arena.free(joined_src_path);
105	104
106	105	const abs_root_src_path = try std.fs.path.resolve(self.arena, &.{ ".", joined_src_path });
...	...	@@ -295,20 +294,20 @@ fn generateZirData(self: *Autodoc, output_dir: std.fs.Dir) !void {
295	294	}
296	295
297	296	const rootName = blk: {
298		const rootName = std.fs.path.basename(self.comp_module.main_pkg.root_src_path);
	297	const rootName = std.fs.path.basename(self.comp_module.main_mod.root_src_path);
299	298	break :blk rootName[0 .. rootName.len - 4];
300	299	};
301	300
302	301	const main_type_index = self.types.items.len;
303	302	{
304		try self.modules.put(self.arena, self.comp_module.main_pkg, .{
	303	try self.modules.put(self.arena, self.comp_module.main_mod, .{
305	304	.name = rootName,
306	305	.main = main_type_index,
307	306	.table = .{},
308	307	});
309	308	try self.modules.entries.items(.value)[0].table.put(
310	309	self.arena,
311		self.comp_module.main_pkg,
	310	self.comp_module.main_mod,
312	311	.{
313	312	.name = rootName,
314	313	.value = 0,
...	...	@@ -412,7 +411,7 @@ fn generateZirData(self: *Autodoc, output_dir: std.fs.Dir) !void {
412	411
413	412	while (files_iterator.next()) \|entry\| {
414	413	const sub_file_path = entry.key_ptr.*.sub_file_path;
415		const file_module = entry.key_ptr.*.pkg;
	414	const file_module = entry.key_ptr.*.mod;
416	415	const module_name = (self.modules.get(file_module) orelse continue).name;
417	416
418	417	const file_path = std.fs.path.dirname(sub_file_path) orelse "";
...	...	@@ -986,12 +985,12 @@ fn walkInstruction(
986	985
987	986	// importFile cannot error out since all files
988	987	// are already loaded at this point
989		if (file.pkg.table.get(path)) \|other_module\| {
	988	if (file.mod.deps.get(path)) \|other_module\| {
990	989	const result = try self.modules.getOrPut(self.arena, other_module);
991	990
992	991	// Immediately add this module to the import table of our
993	992	// current module, regardless of wether it's new or not.
994		if (self.modules.getPtr(file.pkg)) \|current_module\| {
	993	if (self.modules.getPtr(file.mod)) \|current_module\| {
995	994	// TODO: apparently, in the stdlib a file gets analyzed before
996	995	// its module gets added. I guess we're importing a file
997	996	// that belongs to another module through its file path?
...	...	@@ -1025,12 +1024,12 @@ fn walkInstruction(
1025	1024	// TODO: Add this module as a dependency to the current module
1026	1025	// TODO: this seems something that could be done in bulk
1027	1026	// at the beginning or the end, or something.
1028		const root_src_dir = other_module.root_src_directory;
1029		const root_src_path = other_module.root_src_path;
1030		const joined_src_path = try root_src_dir.join(self.arena, &.{root_src_path});
1031		defer self.arena.free(joined_src_path);
1032
1033		const abs_root_src_path = try std.fs.path.resolve(self.arena, &.{ ".", joined_src_path });
	1027	const abs_root_src_path = try std.fs.path.resolve(self.arena, &.{
	1028	".",
	1029	other_module.root.root_dir.path orelse ".",
	1030	other_module.root.sub_path,
	1031	other_module.root_src_path,
	1032	});
1034	1033	defer self.arena.free(abs_root_src_path);
1035	1034
1036	1035	const new_file = self.comp_module.import_table.get(abs_root_src_path).?;
...	...	@@ -5683,7 +5682,7 @@ fn writeFileTableToJson(
5683	5682	while (it.next()) \|entry\| {
5684	5683	try jsw.beginArray();
5685	5684	try jsw.write(entry.key_ptr.*.sub_file_path);
5686		try jsw.write(mods.getIndex(entry.key_ptr.*.pkg) orelse 0);
	5685	try jsw.write(mods.getIndex(entry.key_ptr.*.mod) orelse 0);
5687	5686	try jsw.endArray();
5688	5687	}
5689	5688	try jsw.endArray();
...	...	@@ -5840,7 +5839,7 @@ fn addGuide(self: Autodoc, file: File, guide_path: []const u8, section: *Secti
5840	5839	file.sub_file_path, "..", guide_path,
5841	5840	});
5842	5841
5843		var guide_file = try file.pkg.root_src_directory.handle.openFile(resolved_path, .{});
	5842	var guide_file = try file.mod.root.openFile(resolved_path, .{});
5844	5843	defer guide_file.close();
5845	5844
5846	5845	const guide = guide_file.reader().readAllAlloc(self.arena, 1 * 1024 * 1024) catch \|err\| switch (err) {

src/Compilation.zig+61-80

...	...	@@ -772,12 +772,14 @@ fn addModuleTableToCacheHash(
772	772	switch (hash_type) {
773	773	.path_bytes => {
774	774	hash.addBytes(mod.value.root_src_path);
775		hash.addOptionalBytes(mod.value.root_src_directory.path);
	775	hash.addOptionalBytes(mod.value.root.root_dir.path);
	776	hash.addBytes(mod.value.root.sub_path);
776	777	},
777	778	.files => \|man\| {
778		const pkg_zig_file = try mod.value.root_src_directory.join(allocator, &[_][]const u8{
	779	const pkg_zig_file = try mod.value.root.joinString(
	780	allocator,
779	781	mod.value.root_src_path,
780		});
	782	);
781	783	_ = try man.addFile(pkg_zig_file, null);
782	784	},
783	785	}
...	...	@@ -1310,53 +1312,50 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
1310	1312	const std_mod = if (main_mod_is_std)
1311	1313	main_mod
1312	1314	else
1313		try Package.createWithDir(
1314		gpa,
1315		options.zig_lib_directory,
1316		"std",
1317		"std.zig",
1318		);
1319
1320		errdefer if (!main_mod_is_std) std_mod.destroy(gpa);
	1315	try Package.Module.create(arena, .{
	1316	.root = .{
	1317	.root_dir = options.zig_lib_directory,
	1318	.sub_path = "std",
	1319	},
	1320	.root_src_path = "std.zig",
	1321	});
1321	1322
1322	1323	const root_mod = if (options.is_test) root_mod: {
1323		const test_pkg = if (options.test_runner_path) \|test_runner\| test_pkg: {
1324		const test_dir = std.fs.path.dirname(test_runner);
1325		const basename = std.fs.path.basename(test_runner);
1326		const pkg = try Package.create(gpa, test_dir, basename);
1327
1328		// copy module table from main_mod to root_mod
1329		pkg.deps = try main_mod.deps.clone(gpa);
1330		break :test_pkg pkg;
1331		} else try Package.createWithDir(
1332		gpa,
1333		options.zig_lib_directory,
1334		null,
1335		"test_runner.zig",
1336		);
1337		errdefer test_pkg.destroy(gpa);
	1324	const test_mod = if (options.test_runner_path) \|test_runner\| test_mod: {
	1325	const pkg = try Package.Module.create(arena, .{
	1326	.root = .{
	1327	.root_dir = Directory.cwd(),
	1328	.sub_path = std.fs.path.dirname(test_runner) orelse "",
	1329	},
	1330	.root_src_path = std.fs.path.basename(test_runner),
	1331	});
	1332
	1333	pkg.deps = try main_mod.deps.clone(arena);
	1334	break :test_mod pkg;
	1335	} else try Package.Module.create(arena, .{
	1336	.root = .{
	1337	.root_dir = options.zig_lib_directory,
	1338	},
	1339	.root_src_path = "test_runner.zig",
	1340	});
1338	1341
1339		break :root_mod test_pkg;
	1342	break :root_mod test_mod;
1340	1343	} else main_mod;
1341		errdefer if (options.is_test) root_mod.destroy(gpa);
1342	1344
1343	1345	const compiler_rt_mod = if (include_compiler_rt and options.output_mode == .Obj) compiler_rt_mod: {
1344		break :compiler_rt_mod try Package.createWithDir(
1345		gpa,
1346		options.zig_lib_directory,
1347		null,
1348		"compiler_rt.zig",
1349		);
	1346	break :compiler_rt_mod try Package.Module.create(arena, .{
	1347	.root = .{
	1348	.root_dir = options.zig_lib_directory,
	1349	},
	1350	.root_src_path = "compiler_rt.zig",
	1351	});
1350	1352	} else null;
1351		errdefer if (compiler_rt_mod) \|p\| p.destroy(gpa);
1352
1353		try main_mod.add(gpa, "builtin", builtin_mod);
1354		try main_mod.add(gpa, "root", root_mod);
1355		try main_mod.add(gpa, "std", std_mod);
1356	1353
1357		if (compiler_rt_mod) \|p\| {
1358		try main_mod.add(gpa, "compiler_rt", p);
1359		}
	1354	try main_mod.deps.put(gpa, "builtin", builtin_mod);
	1355	try main_mod.deps.put(gpa, "root", root_mod);
	1356	try main_mod.deps.put(gpa, "std", std_mod);
	1357	if (compiler_rt_mod) \|m\|
	1358	try main_mod.deps.put(gpa, "compiler_rt", m);
1360	1359
1361	1360	// Pre-open the directory handles for cached ZIR code so that it does not need
1362	1361	// to redundantly happen for each AstGen operation.
...	...	@@ -2004,7 +2003,7 @@ fn restorePrevZigCacheArtifactDirectory(comp: Compilation, directory: Director
2004	2003	// on the handle of zig_cache_artifact_directory.
2005	2004	if (comp.bin_file.options.module) \|module\| {
2006	2005	const builtin_mod = module.main_mod.deps.get("builtin").?;
2007		module.zig_cache_artifact_directory = builtin_mod.root_src_directory;
	2006	module.zig_cache_artifact_directory = builtin_mod.root.root_dir;
2008	2007	}
2009	2008	}
2010	2009
...	...	@@ -2418,9 +2417,7 @@ fn addNonIncrementalStuffToCacheManifest(comp: Compilation, man: Cache.Manifes
2418	2417	comptime assert(link_hash_implementation_version == 10);
2419	2418
2420	2419	if (comp.bin_file.options.module) \|mod\| {
2421		const main_zig_file = try mod.main_mod.root_src_directory.join(arena, &[_][]const u8{
2422		mod.main_mod.root_src_path,
2423		});
	2420	const main_zig_file = try mod.main_mod.root.joinString(arena, mod.main_mod.root_src_path);
2424	2421	_ = try man.addFile(main_zig_file, null);
2425	2422	{
2426	2423	var seen_table = std.AutoHashMap(*Package.Module, void).init(arena);
...	...	@@ -2614,23 +2611,23 @@ fn reportMultiModuleErrors(mod: *Module) !void {
2614	2611	errdefer for (notes[0..i]) \|*n\| n.deinit(mod.gpa);
2615	2612	note.* = switch (ref) {
2616	2613	.import => \|loc\| blk: {
2617		const name = try loc.file_scope.pkg.getName(mod.gpa, mod.*);
2618		defer mod.gpa.free(name);
	2614	//const name = try loc.file_scope.mod.getName(mod.gpa, mod.*);
	2615	//defer mod.gpa.free(name);
2619	2616	break :blk try Module.ErrorMsg.init(
2620	2617	mod.gpa,
2621	2618	loc,
2622		"imported from module {s}",
2623		.{name},
	2619	"imported from module {}",
	2620	.{loc.file_scope.mod.root},
2624	2621	);
2625	2622	},
2626	2623	.root => \|pkg\| blk: {
2627		const name = try pkg.getName(mod.gpa, mod.*);
2628		defer mod.gpa.free(name);
	2624	//const name = try pkg.getName(mod.gpa, mod.*);
	2625	//defer mod.gpa.free(name);
2629	2626	break :blk try Module.ErrorMsg.init(
2630	2627	mod.gpa,
2631	2628	.{ .file_scope = file, .parent_decl_node = 0, .lazy = .entire_file },
2632		"root of module {s}",
2633		.{name},
	2629	"root of module {}",
	2630	.{pkg.root},
2634	2631	);
2635	2632	},
2636	2633	};
...	...	@@ -4212,17 +4209,9 @@ fn reportRetryableAstGenError(
4212	4209	},
4213	4210	};
4214	4211
4215		const err_msg = if (file.pkg.root_src_directory.path) \|dir_path\|
4216		try Module.ErrorMsg.create(
4217		gpa,
4218		src_loc,
4219		"unable to load '{s}" ++ std.fs.path.sep_str ++ "{s}': {s}",
4220		.{ dir_path, file.sub_file_path, @errorName(err) },
4221		)
4222		else
4223		try Module.ErrorMsg.create(gpa, src_loc, "unable to load '{s}': {s}", .{
4224		file.sub_file_path, @errorName(err),
4225		});
	4212	const err_msg = try Module.ErrorMsg.create(gpa, src_loc, "unable to load '{}{s}': {s}", .{
	4213	file.mod.root, file.sub_file_path, @errorName(err),
	4214	});
4226	4215	errdefer err_msg.destroy(gpa);
4227	4216
4228	4217	{
...	...	@@ -4242,17 +4231,10 @@ fn reportRetryableEmbedFileError(
4242	4231
4243	4232	const src_loc: Module.SrcLoc = mod.declPtr(embed_file.owner_decl).srcLoc(mod);
4244	4233
4245		const err_msg = if (embed_file.pkg.root_src_directory.path) \|dir_path\|
4246		try Module.ErrorMsg.create(
4247		gpa,
4248		src_loc,
4249		"unable to load '{s}" ++ std.fs.path.sep_str ++ "{s}': {s}",
4250		.{ dir_path, embed_file.sub_file_path, @errorName(err) },
4251		)
4252		else
4253		try Module.ErrorMsg.create(gpa, src_loc, "unable to load '{s}': {s}", .{
4254		embed_file.sub_file_path, @errorName(err),
4255		});
	4234	const err_msg = try Module.ErrorMsg.create(gpa, src_loc, "unable to load '{}{s}': {s}", .{
	4235	embed_file.mod.root, embed_file.sub_file_path, @errorName(err),
	4236	});
	4237
4256	4238	errdefer err_msg.destroy(gpa);
4257	4239
4258	4240	{
...	...	@@ -6375,13 +6357,12 @@ fn buildOutputFromZig(
6375	6357	const tracy_trace = trace(@src());
6376	6358	defer tracy_trace.end();
6377	6359
6378		std.debug.assert(output_mode != .Exe);
	6360	assert(output_mode != .Exe);
6379	6361
6380		var main_mod: Package = .{
6381		.root_src_directory = comp.zig_lib_directory,
	6362	var main_mod: Package.Module = .{
	6363	.root = .{ .root_dir = comp.zig_lib_directory },
6382	6364	.root_src_path = src_basename,
6383	6365	};
6384		defer main_mod.deinitTable(comp.gpa);
6385	6366	const root_name = src_basename[0 .. src_basename.len - std.fs.path.extension(src_basename).len];
6386	6367	const target = comp.getTarget();
6387	6368	const bin_basename = try std.zig.binNameAlloc(comp.gpa, .{

src/Module.zig+75-89

...	...	@@ -998,8 +998,8 @@ pub const File = struct {
998	998	pub const Reference = union(enum) {
999	999	/// The file is imported directly (i.e. not as a package) with @import.
1000	1000	import: SrcLoc,
1001		/// The file is the root of a package.
1002		root: *Package,
	1001	/// The file is the root of a module.
	1002	root: *Package.Module,
1003	1003	};
1004	1004
1005	1005	pub fn unload(file: *File, gpa: Allocator) void {
...	...	@@ -1174,10 +1174,10 @@ pub const File = struct {
1174	1174	}
1175	1175
1176	1176	const pkg = switch (ref) {
1177		.import => \|loc\| loc.file_scope.pkg,
	1177	.import => \|loc\| loc.file_scope.mod,
1178	1178	.root => \|pkg\| pkg,
1179	1179	};
1180		if (pkg != file.pkg) file.multi_pkg = true;
	1180	if (pkg != file.mod) file.multi_pkg = true;
1181	1181	}
1182	1182
1183	1183	/// Mark this file and every file referenced by it as multi_pkg and report an
...	...	@@ -1219,7 +1219,7 @@ pub const EmbedFile = struct {
1219	1219	bytes: [:0]const u8,
1220	1220	stat: Cache.File.Stat,
1221	1221	/// Package that this file is a part of, managed externally.
1222		pkg: *Package,
	1222	mod: *Package.Module,
1223	1223	/// The Decl that was created from the `@embedFile` to own this resource.
1224	1224	/// This is how zig knows what other Decl objects to invalidate if the file
1225	1225	/// changes on disk.
...	...	@@ -2535,28 +2535,6 @@ pub fn deinit(mod: *Module) void {
2535	2535	}
2536	2536
2537	2537	mod.deletion_set.deinit(gpa);
2538
2539		// The callsite of `Compilation.create` owns the `main_mod`, however
2540		// Module owns the builtin and std packages that it adds.
2541		if (mod.main_mod.table.fetchRemove("builtin")) \|kv\| {
2542		gpa.free(kv.key);
2543		kv.value.destroy(gpa);
2544		}
2545		if (mod.main_mod.table.fetchRemove("std")) \|kv\| {
2546		gpa.free(kv.key);
2547		// It's possible for main_mod to be std when running 'zig test'! In this case, we must not
2548		// destroy it, since it would lead to a double-free.
2549		if (kv.value != mod.main_mod) {
2550		kv.value.destroy(gpa);
2551		}
2552		}
2553		if (mod.main_mod.table.fetchRemove("root")) \|kv\| {
2554		gpa.free(kv.key);
2555		}
2556		if (mod.root_mod != mod.main_mod) {
2557		mod.root_mod.destroy(gpa);
2558		}
2559
2560	2538	mod.compile_log_text.deinit(gpa);
2561	2539
2562	2540	mod.zig_cache_artifact_directory.handle.close();
...	...	@@ -2703,18 +2681,19 @@ pub fn astGenFile(mod: Module, file: File) !void {
2703	2681	const gpa = mod.gpa;
2704	2682
2705	2683	// In any case we need to examine the stat of the file to determine the course of action.
2706		var source_file = try file.pkg.root_src_directory.handle.openFile(file.sub_file_path, .{});
	2684	var source_file = try file.mod.root.openFile(file.sub_file_path, .{});
2707	2685	defer source_file.close();
2708	2686
2709	2687	const stat = try source_file.stat();
2710	2688
2711		const want_local_cache = file.pkg == mod.main_mod;
	2689	const want_local_cache = file.mod == mod.main_mod;
2712	2690	const digest = hash: {
2713	2691	var path_hash: Cache.HashHelper = .{};
2714	2692	path_hash.addBytes(build_options.version);
2715	2693	path_hash.add(builtin.zig_backend);
2716	2694	if (!want_local_cache) {
2717		path_hash.addOptionalBytes(file.pkg.root_src_directory.path);
	2695	path_hash.addOptionalBytes(file.mod.root.root_dir.path);
	2696	path_hash.addBytes(file.mod.root.sub_path);
2718	2697	}
2719	2698	path_hash.addBytes(file.sub_file_path);
2720	2699	break :hash path_hash.final();
...	...	@@ -2939,10 +2918,8 @@ pub fn astGenFile(mod: Module, file: File) !void {
2939	2918	},
2940	2919	};
2941	2920	cache_file.writevAll(&iovecs) catch \|err\| {
2942		const pkg_path = file.pkg.root_src_directory.path orelse ".";
2943		const cache_path = cache_directory.path orelse ".";
2944		log.warn("unable to write cached ZIR code for {s}/{s} to {s}/{s}: {s}", .{
2945		pkg_path, file.sub_file_path, cache_path, &digest, @errorName(err),
	2921	log.warn("unable to write cached ZIR code for {}{s} to {}{s}: {s}", .{
	2922	file.mod.root, file.sub_file_path, cache_directory, &digest, @errorName(err),
2946	2923	});
2947	2924	};
2948	2925
...	...	@@ -3147,34 +3124,24 @@ pub fn populateBuiltinFile(mod: *Module) !void {
3147	3124	defer tracy.end();
3148	3125
3149	3126	const comp = mod.comp;
3150		const pkg_and_file = blk: {
	3127	const builtin_mod, const file = blk: {
3151	3128	comp.mutex.lock();
3152	3129	defer comp.mutex.unlock();
3153	3130
3154		const builtin_mod = mod.main_mod.table.get("builtin").?;
	3131	const builtin_mod = mod.main_mod.deps.get("builtin").?;
3155	3132	const result = try mod.importPkg(builtin_mod);
3156		break :blk .{
3157		.file = result.file,
3158		.pkg = builtin_mod,
3159		};
	3133	break :blk .{ builtin_mod, result.file };
3160	3134	};
3161		const file = pkg_and_file.file;
3162		const builtin_mod = pkg_and_file.pkg;
3163	3135	const gpa = mod.gpa;
3164	3136	file.source = try comp.generateBuiltinZigSource(gpa);
3165	3137	file.source_loaded = true;
3166	3138
3167		if (builtin_mod.root_src_directory.handle.statFile(builtin_mod.root_src_path)) \|stat\| {
	3139	if (builtin_mod.root.statFile(builtin_mod.root_src_path)) \|stat\| {
3168	3140	if (stat.size != file.source.len) {
3169		const full_path = try builtin_mod.root_src_directory.join(gpa, &.{
3170		builtin_mod.root_src_path,
3171		});
3172		defer gpa.free(full_path);
3173
3174	3141	log.warn(
3175		"the cached file '{s}' had the wrong size. Expected {d}, found {d}. " ++
	3142	"the cached file '{}{s}' had the wrong size. Expected {d}, found {d}. " ++
3176	3143	"Overwriting with correct file contents now",
3177		.{ full_path, file.source.len, stat.size },
	3144	.{ builtin_mod.root, builtin_mod.root_src_path, file.source.len, stat.size },
3178	3145	);
3179	3146
3180	3147	try writeBuiltinFile(file, builtin_mod);
...	...	@@ -3206,7 +3173,7 @@ pub fn populateBuiltinFile(mod: *Module) !void {
3206	3173	}
3207	3174
3208	3175	fn writeBuiltinFile(file: File, builtin_mod: Package.Module) !void {
3209		var af = try builtin_mod.root_src_directory.handle.atomicFile(builtin_mod.root_src_path, .{});
	3176	var af = try builtin_mod.root.atomicFile(builtin_mod.root_src_path, .{});
3210	3177	defer af.deinit();
3211	3178	try af.file.writeAll(file.source);
3212	3179	try af.finish();
...	...	@@ -3602,7 +3569,8 @@ pub fn updateEmbedFile(mod: Module, embed_file: EmbedFile) SemaError!void {
3602	3569	}
3603	3570	}
3604	3571
3605		pub fn semaPkg(mod: Module, pkg: Package) !void {
	3572	/// https://github.com/ziglang/zig/issues/14307
	3573	pub fn semaPkg(mod: Module, pkg: Package.Module) !void {
3606	3574	const file = (try mod.importPkg(pkg)).file;
3607	3575	return mod.semaFile(file);
3608	3576	}
...	...	@@ -3704,13 +3672,11 @@ pub fn semaFile(mod: Module, file: File) SemaError!void {
3704	3672	return error.AnalysisFail;
3705	3673	};
3706	3674
3707		const resolved_path = std.fs.path.resolve(
3708		gpa,
3709		if (file.pkg.root_src_directory.path) \|pkg_path\|
3710		&[_][]const u8{ pkg_path, file.sub_file_path }
3711		else
3712		&[_][]const u8{file.sub_file_path},
3713		) catch \|err\| {
	3675	const resolved_path = std.fs.path.resolve(gpa, &.{
	3676	file.mod.root.root_dir.path orelse ".",
	3677	file.mod.root.sub_path,
	3678	file.sub_file_path,
	3679	}) catch \|err\| {
3714	3680	try reportRetryableFileError(mod, file, "unable to resolve path: {s}", .{@errorName(err)});
3715	3681	return error.AnalysisFail;
3716	3682	};
...	...	@@ -3741,8 +3707,8 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !bool {
3741	3707
3742	3708	// TODO: figure out how this works under incremental changes to builtin.zig!
3743	3709	const builtin_type_target_index: InternPool.Index = blk: {
3744		const std_mod = mod.main_mod.table.get("std").?;
3745		if (decl.getFileScope(mod).pkg != std_mod) break :blk .none;
	3710	const std_mod = mod.main_mod.deps.get("std").?;
	3711	if (decl.getFileScope(mod).mod != std_mod) break :blk .none;
3746	3712	// We're in the std module.
3747	3713	const std_file = (try mod.importPkg(std_mod)).file;
3748	3714	const std_decl = mod.declPtr(std_file.root_decl.unwrap().?);
...	...	@@ -4035,14 +4001,17 @@ pub const ImportFileResult = struct {
4035	4001	is_pkg: bool,
4036	4002	};
4037	4003
4038		pub fn importPkg(mod: Module, pkg: Package) !ImportFileResult {
	4004	/// https://github.com/ziglang/zig/issues/14307
	4005	pub fn importPkg(mod: Module, pkg: Package.Module) !ImportFileResult {
4039	4006	const gpa = mod.gpa;
4040	4007
4041	4008	// The resolved path is used as the key in the import table, to detect if
4042	4009	// an import refers to the same as another, despite different relative paths
4043	4010	// or differently mapped package names.
4044		const resolved_path = try std.fs.path.resolve(gpa, &[_][]const u8{
4045		pkg.root_src_directory.path orelse ".", pkg.root_src_path,
	4011	const resolved_path = try std.fs.path.resolve(gpa, &.{
	4012	pkg.root.root_dir.path orelse ".",
	4013	pkg.root.sub_path,
	4014	pkg.root_src_path,
4046	4015	});
4047	4016	var keep_resolved_path = false;
4048	4017	defer if (!keep_resolved_path) gpa.free(resolved_path);
...	...	@@ -4076,7 +4045,7 @@ pub fn importPkg(mod: Module, pkg: Package) !ImportFileResult {
4076	4045	.tree = undefined,
4077	4046	.zir = undefined,
4078	4047	.status = .never_loaded,
4079		.pkg = pkg,
	4048	.mod = pkg,
4080	4049	.root_decl = .none,
4081	4050	};
4082	4051	try new_file.addReference(mod.*, .{ .root = pkg });
...	...	@@ -4093,15 +4062,15 @@ pub fn importFile(
4093	4062	import_string: []const u8,
4094	4063	) !ImportFileResult {
4095	4064	if (std.mem.eql(u8, import_string, "std")) {
4096		return mod.importPkg(mod.main_mod.table.get("std").?);
	4065	return mod.importPkg(mod.main_mod.deps.get("std").?);
4097	4066	}
4098	4067	if (std.mem.eql(u8, import_string, "builtin")) {
4099		return mod.importPkg(mod.main_mod.table.get("builtin").?);
	4068	return mod.importPkg(mod.main_mod.deps.get("builtin").?);
4100	4069	}
4101	4070	if (std.mem.eql(u8, import_string, "root")) {
4102	4071	return mod.importPkg(mod.root_mod);
4103	4072	}
4104		if (cur_file.pkg.table.get(import_string)) \|pkg\| {
	4073	if (cur_file.mod.deps.get(import_string)) \|pkg\| {
4105	4074	return mod.importPkg(pkg);
4106	4075	}
4107	4076	if (!mem.endsWith(u8, import_string, ".zig")) {
...	...	@@ -4112,10 +4081,14 @@ pub fn importFile(
4112	4081	// The resolved path is used as the key in the import table, to detect if
4113	4082	// an import refers to the same as another, despite different relative paths
4114	4083	// or differently mapped package names.
4115		const cur_pkg_dir_path = cur_file.pkg.root_src_directory.path orelse ".";
4116		const resolved_path = try std.fs.path.resolve(gpa, &[_][]const u8{
4117		cur_pkg_dir_path, cur_file.sub_file_path, "..", import_string,
	4084	const resolved_path = try std.fs.path.resolve(gpa, &.{
	4085	cur_file.mod.root.root_dir.path orelse ".",
	4086	cur_file.mod.root.sub_path,
	4087	cur_file.sub_file_path,
	4088	"..",
	4089	import_string,
4118	4090	});
	4091
4119	4092	var keep_resolved_path = false;
4120	4093	defer if (!keep_resolved_path) gpa.free(resolved_path);
4121	4094
...	...	@@ -4130,7 +4103,10 @@ pub fn importFile(
4130	4103	const new_file = try gpa.create(File);
4131	4104	errdefer gpa.destroy(new_file);
4132	4105
4133		const resolved_root_path = try std.fs.path.resolve(gpa, &[_][]const u8{cur_pkg_dir_path});
	4106	const resolved_root_path = try std.fs.path.resolve(gpa, &.{
	4107	cur_file.mod.root.root_dir.path orelse ".",
	4108	cur_file.mod.root.sub_path,
	4109	});
4134	4110	defer gpa.free(resolved_root_path);
4135	4111
4136	4112	const sub_file_path = p: {
...	...	@@ -4164,7 +4140,7 @@ pub fn importFile(
4164	4140	.tree = undefined,
4165	4141	.zir = undefined,
4166	4142	.status = .never_loaded,
4167		.pkg = cur_file.pkg,
	4143	.mod = cur_file.mod,
4168	4144	.root_decl = .none,
4169	4145	};
4170	4146	return ImportFileResult{
...	...	@@ -4177,9 +4153,11 @@ pub fn importFile(
4177	4153	pub fn embedFile(mod: Module, cur_file: File, import_string: []const u8) !*EmbedFile {
4178	4154	const gpa = mod.gpa;
4179	4155
4180		if (cur_file.pkg.table.get(import_string)) \|pkg\| {
4181		const resolved_path = try std.fs.path.resolve(gpa, &[_][]const u8{
4182		pkg.root_src_directory.path orelse ".", pkg.root_src_path,
	4156	if (cur_file.mod.deps.get(import_string)) \|pkg\| {
	4157	const resolved_path = try std.fs.path.resolve(gpa, &.{
	4158	pkg.root.root_dir.path orelse ".",
	4159	pkg.root.sub_path,
	4160	pkg.root_src_path,
4183	4161	});
4184	4162	var keep_resolved_path = false;
4185	4163	defer if (!keep_resolved_path) gpa.free(resolved_path);
...	...	@@ -4196,10 +4174,14 @@ pub fn embedFile(mod: Module, cur_file: File, import_string: []const u8) !*Emb
4196	4174
4197	4175	// The resolved path is used as the key in the table, to detect if a file
4198	4176	// refers to the same as another, despite different relative paths.
4199		const cur_pkg_dir_path = cur_file.pkg.root_src_directory.path orelse ".";
4200		const resolved_path = try std.fs.path.resolve(gpa, &[_][]const u8{
4201		cur_pkg_dir_path, cur_file.sub_file_path, "..", import_string,
	4177	const resolved_path = try std.fs.path.resolve(gpa, &.{
	4178	cur_file.mod.root.root_dir.path orelse ".",
	4179	cur_file.mod.root.sub_path,
	4180	cur_file.sub_file_path,
	4181	"..",
	4182	import_string,
4202	4183	});
	4184
4203	4185	var keep_resolved_path = false;
4204	4186	defer if (!keep_resolved_path) gpa.free(resolved_path);
4205	4187
...	...	@@ -4207,7 +4189,10 @@ pub fn embedFile(mod: Module, cur_file: File, import_string: []const u8) !*Emb
4207	4189	errdefer assert(mod.embed_table.remove(resolved_path));
4208	4190	if (gop.found_existing) return gop.value_ptr.*;
4209	4191
4210		const resolved_root_path = try std.fs.path.resolve(gpa, &[_][]const u8{cur_pkg_dir_path});
	4192	const resolved_root_path = try std.fs.path.resolve(gpa, &.{
	4193	cur_file.mod.root.root_dir.path orelse ".",
	4194	cur_file.mod.root.sub_path,
	4195	});
4211	4196	defer gpa.free(resolved_root_path);
4212	4197
4213	4198	const sub_file_path = p: {
...	...	@@ -4225,12 +4210,13 @@ pub fn embedFile(mod: Module, cur_file: File, import_string: []const u8) !*Emb
4225	4210	};
4226	4211	errdefer gpa.free(sub_file_path);
4227	4212
4228		return newEmbedFile(mod, cur_file.pkg, sub_file_path, resolved_path, &keep_resolved_path, gop);
	4213	return newEmbedFile(mod, cur_file.mod, sub_file_path, resolved_path, &keep_resolved_path, gop);
4229	4214	}
4230	4215
	4216	/// https://github.com/ziglang/zig/issues/14307
4231	4217	fn newEmbedFile(
4232	4218	mod: *Module,
4233		pkg: *Package,
	4219	pkg: *Package.Module,
4234	4220	sub_file_path: []const u8,
4235	4221	resolved_path: []const u8,
4236	4222	keep_resolved_path: *bool,
...	...	@@ -4241,7 +4227,7 @@ fn newEmbedFile(
4241	4227	const new_file = try gpa.create(EmbedFile);
4242	4228	errdefer gpa.destroy(new_file);
4243	4229
4244		var file = try pkg.root_src_directory.handle.openFile(sub_file_path, .{});
	4230	var file = try pkg.root.openFile(sub_file_path, .{});
4245	4231	defer file.close();
4246	4232
4247	4233	const actual_stat = try file.stat();
...	...	@@ -4268,14 +4254,14 @@ fn newEmbedFile(
4268	4254	.sub_file_path = sub_file_path,
4269	4255	.bytes = bytes,
4270	4256	.stat = stat,
4271		.pkg = pkg,
	4257	.mod = pkg,
4272	4258	.owner_decl = undefined, // Set by Sema immediately after this function returns.
4273	4259	};
4274	4260	return new_file;
4275	4261	}
4276	4262
4277	4263	pub fn detectEmbedFileUpdate(mod: Module, embed_file: EmbedFile) !void {
4278		var file = try embed_file.pkg.root_src_directory.handle.openFile(embed_file.sub_file_path, .{});
	4264	var file = try embed_file.mod.root.openFile(embed_file.sub_file_path, .{});
4279	4265	defer file.close();
4280	4266
4281	4267	const stat = try file.stat();
...	...	@@ -4448,21 +4434,21 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) Allocator.Err
4448	4434	gop.key_ptr.* = new_decl_index;
4449	4435	// Exported decls, comptime decls, usingnamespace decls, and
4450	4436	// test decls if in test mode, get analyzed.
4451		const decl_pkg = namespace.file_scope.pkg;
	4437	const decl_mod = namespace.file_scope.mod;
4452	4438	const want_analysis = is_exported or switch (decl_name_index) {
4453	4439	0 => true, // comptime or usingnamespace decl
4454	4440	1 => blk: {
4455	4441	// test decl with no name. Skip the part where we check against
4456	4442	// the test name filter.
4457	4443	if (!comp.bin_file.options.is_test) break :blk false;
4458		if (decl_pkg != mod.main_mod) break :blk false;
	4444	if (decl_mod != mod.main_mod) break :blk false;
4459	4445	try mod.test_functions.put(gpa, new_decl_index, {});
4460	4446	break :blk true;
4461	4447	},
4462	4448	else => blk: {
4463	4449	if (!is_named_test) break :blk false;
4464	4450	if (!comp.bin_file.options.is_test) break :blk false;
4465		if (decl_pkg != mod.main_mod) break :blk false;
	4451	if (decl_mod != mod.main_mod) break :blk false;
4466	4452	if (comp.test_filter) \|test_filter\| {
4467	4453	if (mem.indexOf(u8, ip.stringToSlice(decl_name), test_filter) == null) {
4468	4454	break :blk false;
...	...	@@ -5589,7 +5575,7 @@ pub fn populateTestFunctions(
5589	5575	) !void {
5590	5576	const gpa = mod.gpa;
5591	5577	const ip = &mod.intern_pool;
5592		const builtin_mod = mod.main_mod.table.get("builtin").?;
	5578	const builtin_mod = mod.main_mod.deps.get("builtin").?;
5593	5579	const builtin_file = (mod.importPkg(builtin_mod) catch unreachable).file;
5594	5580	const root_decl = mod.declPtr(builtin_file.root_decl.unwrap().?);
5595	5581	const builtin_namespace = mod.namespacePtr(root_decl.src_namespace);

src/Package.zig+29-4

...	...	@@ -13,12 +13,13 @@ pub const Path = struct {
13	13	return .{ .root_dir = Cache.Directory.cwd() };
14	14	}
15	15
16		pub fn join(p: Path, allocator: Allocator, sub_path: []const u8) Allocator.Error!Path {
	16	pub fn join(p: Path, arena: Allocator, sub_path: []const u8) Allocator.Error!Path {
	17	if (sub_path.len == 0) return p;
17	18	const parts: []const []const u8 =
18	19	if (p.sub_path.len == 0) &.{sub_path} else &.{ p.sub_path, sub_path };
19	20	return .{
20	21	.root_dir = p.root_dir,
21		.sub_path = try fs.path.join(allocator, parts),
	22	.sub_path = try fs.path.join(arena, parts),
22	23	};
23	24	}
24	25
...	...	@@ -28,7 +29,7 @@ pub const Path = struct {
28	29	return p.root_dir.join(allocator, parts);
29	30	}
30	31
31		pub fn joinStringZ(p: Path, allocator: Allocator, sub_path: []const u8) Allocator.Error![]u8 {
	32	pub fn joinStringZ(p: Path, allocator: Allocator, sub_path: []const u8) Allocator.Error![:0]u8 {
32	33	const parts: []const []const u8 =
33	34	if (p.sub_path.len == 0) &.{sub_path} else &.{ p.sub_path, sub_path };
34	35	return p.root_dir.joinZ(allocator, parts);
...	...	@@ -38,7 +39,7 @@ pub const Path = struct {
38	39	p: Path,
39	40	sub_path: []const u8,
40	41	flags: fs.File.OpenFlags,
41		) fs.File.OpenError!fs.File {
	42	) !fs.File {
42	43	var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
43	44	const joined_path = if (p.sub_path.len == 0) sub_path else p: {
44	45	break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
...	...	@@ -58,6 +59,30 @@ pub const Path = struct {
58	59	return p.root_dir.handle.makeOpenPath(joined_path, opts);
59	60	}
60	61
	62	pub fn statFile(p: Path, sub_path: []const u8) !fs.Dir.Stat {
	63	var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
	64	const joined_path = if (p.sub_path.len == 0) sub_path else p: {
	65	break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
	66	p.sub_path, sub_path,
	67	}) catch return error.NameTooLong;
	68	};
	69	return p.root_dir.handle.statFile(joined_path);
	70	}
	71
	72	pub fn atomicFile(
	73	p: Path,
	74	sub_path: []const u8,
	75	options: fs.Dir.AtomicFileOptions,
	76	) !fs.AtomicFile {
	77	var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
	78	const joined_path = if (p.sub_path.len == 0) sub_path else p: {
	79	break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
	80	p.sub_path, sub_path,
	81	}) catch return error.NameTooLong;
	82	};
	83	return p.root_dir.handle.atomicFile(joined_path, options);
	84	}
	85
61	86	pub fn format(
62	87	self: Path,
63	88	comptime fmt_string: []const u8,

src/Package/Fetch.zig+28-2

...	...	@@ -49,7 +49,7 @@ allow_missing_paths_field: bool,
49	49	/// This will either be relative to `global_cache`, or to the build root of
50	50	/// the root package.
51	51	package_root: Package.Path,
52		error_bundle: std.zig.ErrorBundle.Wip,
	52	error_bundle: ErrorBundle.Wip,
53	53	manifest: ?Manifest,
54	54	manifest_ast: std.zig.Ast,
55	55	actual_hash: Manifest.Digest,
...	...	@@ -89,6 +89,31 @@ pub const JobQueue = struct {
89	89	jq.all_fetches.deinit(gpa);
90	90	jq.* = undefined;
91	91	}
	92
	93	/// Dumps all subsequent error bundles into the first one.
	94	pub fn consolidateErrors(jq: *JobQueue) !void {
	95	const root = &jq.all_fetches.items[0].error_bundle;
	96	for (jq.all_fetches.items[1..]) \|fetch\| {
	97	if (fetch.error_bundle.root_list.items.len > 0) {
	98	try root.addBundleAsRoots(fetch.error_bundle.tmpBundle());
	99	}
	100	}
	101	}
	102
	103	/// Creates the dependencies.zig file and corresponding `Module` for the
	104	/// build runner to obtain via `@import("@dependencies")`.
	105	pub fn createDependenciesModule(
	106	jq: *JobQueue,
	107	arena: Allocator,
	108	local_cache_directory: Cache.Directory,
	109	basename: []const u8,
	110	) !*Package.Module {
	111	_ = jq;
	112	_ = arena;
	113	_ = local_cache_directory;
	114	_ = basename;
	115	@panic("TODO: createDependenciesModule");
	116	}
92	117	};
93	118
94	119	pub const Location = union(enum) {
...	...	@@ -502,7 +527,7 @@ pub fn workerRun(f: *Fetch) void {
502	527	fn srcLoc(
503	528	f: *Fetch,
504	529	tok: std.zig.Ast.TokenIndex,
505		) Allocator.Error!std.zig.ErrorBundle.SourceLocationIndex {
	530	) Allocator.Error!ErrorBundle.SourceLocationIndex {
506	531	const ast = f.parent_manifest_ast orelse return .none;
507	532	const eb = &f.error_bundle;
508	533	const token_starts = ast.tokens.items(.start);
...	...	@@ -1258,3 +1283,4 @@ const Fetch = @This();
1258	1283	const main = @import("../main.zig");
1259	1284	const git = @import("../git.zig");
1260	1285	const Package = @import("../Package.zig");
	1286	const ErrorBundle = std.zig.ErrorBundle;

src/Package/Module.zig+1-1

...	...	@@ -8,7 +8,7 @@ root: Package.Path,
8	8	root_src_path: []const u8,
9	9	/// The dependency table of this module. Shared dependencies such as 'std',
10	10	/// 'builtin', and 'root' are not specified in every dependency table, but
11		/// instead only in the table of `main_pkg`. `Module.importFile` is
	11	/// instead only in the table of `main_mod`. `Module.importFile` is
12	12	/// responsible for detecting these names and using the correct package.
13	13	deps: Deps = .{},
14	14

src/Sema.zig+7-5

...	...	@@ -13075,9 +13075,11 @@ fn zirImport(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.
13075	13075	return sema.fail(block, operand_src, "import of file outside package path: '{s}'", .{operand});
13076	13076	},
13077	13077	error.PackageNotFound => {
13078		const name = try block.getFileScope(mod).pkg.getName(sema.gpa, mod.*);
13079		defer sema.gpa.free(name);
13080		return sema.fail(block, operand_src, "no package named '{s}' available within package '{s}'", .{ operand, name });
	13078	//const name = try block.getFileScope(mod).mod.getName(sema.gpa, mod.*);
	13079	//defer sema.gpa.free(name);
	13080	return sema.fail(block, operand_src, "no package named '{s}' available within package '{}'", .{
	13081	operand, block.getFileScope(mod).mod.root,
	13082	});
13081	13083	},
13082	13084	else => {
13083	13085	// TODO: these errors are file system errors; make sure an update() will
...	...	@@ -36415,8 +36417,8 @@ fn getBuiltinDecl(sema: Sema, block: Block, name: []const u8) CompileError!Mod
36415	36417
36416	36418	const mod = sema.mod;
36417	36419	const ip = &mod.intern_pool;
36418		const std_pkg = mod.main_pkg.table.get("std").?;
36419		const std_file = (mod.importPkg(std_pkg) catch unreachable).file;
	36420	const std_mod = mod.main_mod.deps.get("std").?;
	36421	const std_file = (mod.importPkg(std_mod) catch unreachable).file;
36420	36422	const opt_builtin_inst = (try sema.namespaceLookupRef(
36421	36423	block,
36422	36424	src,

src/codegen/llvm.zig+16-13

...	...	@@ -892,21 +892,24 @@ pub const Object = struct {
892	892	build_options.semver.patch,
893	893	});
894	894
895		// We fully resolve all paths at this point to avoid lack of source line info in stack
896		// traces or lack of debugging information which, if relative paths were used, would
897		// be very location dependent.
	895	// We fully resolve all paths at this point to avoid lack of
	896	// source line info in stack traces or lack of debugging
	897	// information which, if relative paths were used, would be
	898	// very location dependent.
898	899	// TODO: the only concern I have with this is WASI as either host or target, should
899	900	// we leave the paths as relative then?
900	901	var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
901		const compile_unit_dir = blk: {
902		const path = d: {
903		const mod = options.module orelse break :d ".";
904		break :d mod.root_pkg.root_src_directory.path orelse ".";
905		};
906		if (std.fs.path.isAbsolute(path)) break :blk path;
907		break :blk std.os.realpath(path, &buf) catch path; // If realpath fails, fallback to whatever path was
	902	const compile_unit_dir_z = blk: {
	903	if (options.module) \|mod\| {
	904	const d = try mod.root_mod.root.joinStringZ(builder.gpa, "");
	905	if (std.fs.path.isAbsolute(d)) break :blk d;
	906	const abs = std.fs.realpath(d, &buf) catch break :blk d;
	907	builder.gpa.free(d);
	908	break :blk try builder.gpa.dupeZ(u8, abs);
	909	}
	910	const cwd = try std.process.getCwd(&buf);
	911	break :blk try builder.gpa.dupeZ(u8, cwd);
908	912	};
909		const compile_unit_dir_z = try builder.gpa.dupeZ(u8, compile_unit_dir);
910	913	defer builder.gpa.free(compile_unit_dir_z);
911	914
912	915	builder.llvm.di_compile_unit = builder.llvm.di_builder.?.createCompileUnit(
...	...	@@ -2828,8 +2831,8 @@ pub const Object = struct {
2828	2831	fn getStackTraceType(o: *Object) Allocator.Error!Type {
2829	2832	const mod = o.module;
2830	2833
2831		const std_pkg = mod.main_pkg.table.get("std").?;
2832		const std_file = (mod.importPkg(std_pkg) catch unreachable).file;
	2834	const std_mod = mod.main_mod.deps.get("std").?;
	2835	const std_file = (mod.importPkg(std_mod) catch unreachable).file;
2833	2836
2834	2837	const builtin_str = try mod.intern_pool.getOrPutString(mod.gpa, "builtin");
2835	2838	const std_namespace = mod.namespacePtr(mod.declPtr(std_file.root_decl.unwrap().?).src_namespace);

src/glibc.zig+1-1

...	...	@@ -1074,7 +1074,7 @@ fn buildSharedLib(
1074	1074	.cache_mode = .whole,
1075	1075	.target = comp.getTarget(),
1076	1076	.root_name = lib.name,
1077		.main_pkg = null,
	1077	.main_mod = null,
1078	1078	.output_mode = .Lib,
1079	1079	.link_mode = .Dynamic,
1080	1080	.thread_pool = comp.thread_pool,

src/libcxx.zig+2-2

...	...	@@ -233,7 +233,7 @@ pub fn buildLibCXX(comp: Compilation, prog_node: std.Progress.Node) !void {
233	233	.cache_mode = .whole,
234	234	.target = target,
235	235	.root_name = root_name,
236		.main_pkg = null,
	236	.main_mod = null,
237	237	.output_mode = output_mode,
238	238	.thread_pool = comp.thread_pool,
239	239	.libc_installation = comp.bin_file.options.libc_installation,
...	...	@@ -396,7 +396,7 @@ pub fn buildLibCXXABI(comp: Compilation, prog_node: std.Progress.Node) !void {
396	396	.cache_mode = .whole,
397	397	.target = target,
398	398	.root_name = root_name,
399		.main_pkg = null,
	399	.main_mod = null,
400	400	.output_mode = output_mode,
401	401	.thread_pool = comp.thread_pool,
402	402	.libc_installation = comp.bin_file.options.libc_installation,

src/libtsan.zig+1-1

...	...	@@ -202,7 +202,7 @@ pub fn buildTsan(comp: Compilation, prog_node: std.Progress.Node) !void {
202	202	.cache_mode = .whole,
203	203	.target = target,
204	204	.root_name = root_name,
205		.main_pkg = null,
	205	.main_mod = null,
206	206	.output_mode = output_mode,
207	207	.thread_pool = comp.thread_pool,
208	208	.libc_installation = comp.bin_file.options.libc_installation,

src/libunwind.zig+1-1

...	...	@@ -89,7 +89,7 @@ pub fn buildStaticLib(comp: Compilation, prog_node: std.Progress.Node) !void {
89	89	.cache_mode = .whole,
90	90	.target = target,
91	91	.root_name = root_name,
92		.main_pkg = null,
	92	.main_mod = null,
93	93	.output_mode = output_mode,
94	94	.thread_pool = comp.thread_pool,
95	95	.libc_installation = comp.bin_file.options.libc_installation,

src/link/Dwarf.zig+13-5

...	...	@@ -1880,7 +1880,7 @@ pub fn writeDbgInfoHeader(self: Dwarf, module: Module, low_pc: u64, high_pc: u
1880	1880	},
1881	1881	}
1882	1882	// Write the form for the compile unit, which must match the abbrev table above.
1883		const name_strp = try self.strtab.insert(self.allocator, module.root_pkg.root_src_path);
	1883	const name_strp = try self.strtab.insert(self.allocator, module.root_mod.root_src_path);
1884	1884	var compile_unit_dir_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
1885	1885	const compile_unit_dir = resolveCompilationDir(module, &compile_unit_dir_buffer);
1886	1886	const comp_dir_strp = try self.strtab.insert(self.allocator, compile_unit_dir);
...	...	@@ -1940,9 +1940,17 @@ fn resolveCompilationDir(module: Module, buffer: [std.fs.MAX_PATH_BYTES]u8) []
1940	1940	// be very location dependent.
1941	1941	// TODO: the only concern I have with this is WASI as either host or target, should
1942	1942	// we leave the paths as relative then?
1943		const comp_dir_path = module.root_pkg.root_src_directory.path orelse ".";
1944		if (std.fs.path.isAbsolute(comp_dir_path)) return comp_dir_path;
1945		return std.os.realpath(comp_dir_path, buffer) catch comp_dir_path; // If realpath fails, fallback to whatever comp_dir_path was
	1943	const root_dir_path = module.root_mod.root.root_dir.path orelse ".";
	1944	const sub_path = module.root_mod.root.sub_path;
	1945	const realpath = if (std.fs.path.isAbsolute(root_dir_path)) r: {
	1946	@memcpy(buffer[0..root_dir_path.len], root_dir_path);
	1947	break :r root_dir_path;
	1948	} else std.fs.realpath(root_dir_path, buffer) catch return root_dir_path;
	1949	const len = realpath.len + 1 + sub_path.len;
	1950	if (buffer.len < len) return root_dir_path;
	1951	buffer[realpath.len] = '/';
	1952	@memcpy(buffer[realpath.len + 1 ..][0..sub_path.len], sub_path);
	1953	return buffer[0..len];
1946	1954	}
1947	1955
1948	1956	fn writeAddrAssumeCapacity(self: Dwarf, buf: std.ArrayList(u8), addr: u64) void {
...	...	@@ -2664,7 +2672,7 @@ fn genIncludeDirsAndFileNames(self: *Dwarf, arena: Allocator) !struct {
2664	2672	for (self.di_files.keys()) \|dif\| {
2665	2673	const dir_path = d: {
2666	2674	var buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
2667		const dir_path = dif.pkg.root_src_directory.path orelse ".";
	2675	const dir_path = try dif.mod.root.joinString(arena, dif.mod.root.sub_path);
2668	2676	const abs_dir_path = if (std.fs.path.isAbsolute(dir_path))
2669	2677	dir_path
2670	2678	else

src/link/Elf.zig+3-3

...	...	@@ -929,15 +929,15 @@ pub fn populateMissingMetadata(self: *Elf) !void {
929	929
930	930	if (self.base.options.module) \|module\| {
931	931	if (self.zig_module_index == null and !self.base.options.use_llvm) {
932		const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
	932	const index: File.Index = @intCast(try self.files.addOne(gpa));
933	933	self.files.set(index, .{ .zig_module = .{
934	934	.index = index,
935		.path = module.main_pkg.root_src_path,
	935	.path = module.main_mod.root_src_path,
936	936	} });
937	937	self.zig_module_index = index;
938	938	const zig_module = self.file(index).?.zig_module;
939	939
940		const name_off = try self.strtab.insert(gpa, std.fs.path.stem(module.main_pkg.root_src_path));
	940	const name_off = try self.strtab.insert(gpa, std.fs.path.stem(module.main_mod.root_src_path));
941	941	const symbol_index = try self.addSymbol();
942	942	try zig_module.local_symbols.append(gpa, symbol_index);
943	943	const symbol_ptr = self.symbol(symbol_index);

src/link/Plan9.zig+6-3

...	...	@@ -352,9 +352,12 @@ fn putFn(self: *Plan9, decl_index: Module.Decl.Index, out: FnDeclOutput) !void {
352	352
353	353	// getting the full file path
354	354	var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
355		const dir = file.pkg.root_src_directory.path orelse try std.os.getcwd(&buf);
356		const sub_path = try std.fs.path.join(arena, &.{ dir, file.sub_file_path });
357		try self.addPathComponents(sub_path, &a);
	355	const full_path = try std.fs.path.join(arena, &.{
	356	file.mod.root.root_dir.path orelse try std.os.getcwd(&buf),
	357	file.mod.root.sub_path,
	358	file.sub_file_path,
	359	});
	360	try self.addPathComponents(full_path, &a);
358	361
359	362	// null terminate
360	363	try a.append(0);

src/main.zig+58-55

...	...	@@ -897,7 +897,7 @@ fn buildOutputType(
897	897	var override_local_cache_dir: ?[]const u8 = try optionalStringEnvVar(arena, "ZIG_LOCAL_CACHE_DIR");
898	898	var override_global_cache_dir: ?[]const u8 = try optionalStringEnvVar(arena, "ZIG_GLOBAL_CACHE_DIR");
899	899	var override_lib_dir: ?[]const u8 = try optionalStringEnvVar(arena, "ZIG_LIB_DIR");
900		var main_pkg_path: ?[]const u8 = null;
	900	var main_mod_path: ?[]const u8 = null;
901	901	var clang_preprocessor_mode: Compilation.ClangPreprocessorMode = .no;
902	902	var subsystem: ?std.Target.SubSystem = null;
903	903	var major_subsystem_version: ?u32 = null;
...	...	@@ -1047,7 +1047,7 @@ fn buildOutputType(
1047	1047	}
1048	1048	root_deps_str = args_iter.nextOrFatal();
1049	1049	} else if (mem.eql(u8, arg, "--main-mod-path")) {
1050		main_pkg_path = args_iter.nextOrFatal();
	1050	main_mod_path = args_iter.nextOrFatal();
1051	1051	} else if (mem.eql(u8, arg, "-cflags")) {
1052	1052	extra_cflags.shrinkRetainingCapacity(0);
1053	1053	while (true) {
...	...	@@ -3236,8 +3236,8 @@ fn buildOutputType(
3236	3236
3237	3237	const main_mod: ?*Package.Module = if (root_src_file) \|unresolved_src_path\| blk: {
3238	3238	const src_path = try introspect.resolvePath(arena, unresolved_src_path);
3239		if (main_pkg_path) \|unresolved_main_pkg_path\| {
3240		const p = try introspect.resolvePath(arena, unresolved_main_pkg_path);
	3239	if (main_mod_path) \|unresolved_main_mod_path\| {
	3240	const p = try introspect.resolvePath(arena, unresolved_main_mod_path);
3241	3241	break :blk try Package.Module.create(arena, .{
3242	3242	.root = .{
3243	3243	.root_dir = Cache.Directory.cwd(),
...	...	@@ -3386,8 +3386,6 @@ fn buildOutputType(
3386	3386
3387	3387	gimmeMoreOfThoseSweetSweetFileDescriptors();
3388	3388
3389		if (true) @panic("TODO restore Compilation logic");
3390
3391	3389	const comp = Compilation.create(gpa, .{
3392	3390	.zig_lib_directory = zig_lib_directory,
3393	3391	.local_cache_directory = local_cache_directory,
...	...	@@ -4628,6 +4626,8 @@ pub const usage_build =
4628	4626	;
4629	4627
4630	4628	pub fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
	4629	const work_around_btrfs_bug = builtin.os.tag == .linux and
	4630	std.process.hasEnvVarConstant("ZIG_BTRFS_WORKAROUND");
4631	4631	var color: Color = .auto;
4632	4632
4633	4633	// We want to release all the locks before executing the child process, so we make a nice
...	...	@@ -4725,7 +4725,7 @@ pub fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !voi
4725	4725
4726	4726	const cwd_path = try process.getCwdAlloc(arena);
4727	4727	const build_zig_basename = if (build_file) \|bf\| fs.path.basename(bf) else Package.build_zig_basename;
4728		const build_directory: Compilation.Directory = blk: {
	4728	const build_root: Compilation.Directory = blk: {
4729	4729	if (build_file) \|bf\| {
4730	4730	if (fs.path.dirname(bf)) \|dirname\| {
4731	4731	const dir = fs.cwd().openDir(dirname, .{}) catch \|err\| {
...	...	@@ -4761,7 +4761,7 @@ pub fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !voi
4761	4761	}
4762	4762	}
4763	4763	};
4764		child_argv.items[argv_index_build_file] = build_directory.path orelse cwd_path;
	4764	child_argv.items[argv_index_build_file] = build_root.path orelse cwd_path;
4765	4765
4766	4766	var global_cache_directory: Compilation.Directory = l: {
4767	4767	const p = override_global_cache_dir orelse try introspect.resolveGlobalCacheDir(arena);
...	...	@@ -4781,9 +4781,9 @@ pub fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !voi
4781	4781	.path = local_cache_dir_path,
4782	4782	};
4783	4783	}
4784		const cache_dir_path = try build_directory.join(arena, &[_][]const u8{"zig-cache"});
	4784	const cache_dir_path = try build_root.join(arena, &[_][]const u8{"zig-cache"});
4785	4785	break :l .{
4786		.handle = try build_directory.handle.makeOpenPath("zig-cache", .{}),
	4786	.handle = try build_root.handle.makeOpenPath("zig-cache", .{}),
4787	4787	.path = cache_dir_path,
4788	4788	};
4789	4789	};
...	...	@@ -4824,74 +4824,77 @@ pub fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !voi
4824	4824	};
4825	4825
4826	4826	var build_mod: Package.Module = .{
4827		.root = .{ .root_dir = build_directory },
	4827	.root = .{ .root_dir = build_root },
4828	4828	.root_src_path = build_zig_basename,
4829	4829	};
4830	4830	if (build_options.only_core_functionality) {
4831		const deps_pkg = try Package.createFilePkg(gpa, local_cache_directory, "dependencies.zig",
	4831	const deps_mod = try Package.createFilePkg(gpa, local_cache_directory, "dependencies.zig",
4832	4832	\\pub const packages = struct {};
4833	4833	\\pub const root_deps: []const struct { []const u8, []const u8 } = &.{};
4834	4834	\\
4835	4835	);
4836		try main_mod.deps.put(arena, "@dependencies", deps_pkg);
	4836	try main_mod.deps.put(arena, "@dependencies", deps_mod);
4837	4837	} else {
4838	4838	var http_client: std.http.Client = .{ .allocator = gpa };
4839	4839	defer http_client.deinit();
4840	4840
4841		if (true) @panic("TODO restore package fetching logic");
4842
4843		// Here we provide an import to the build runner that allows using reflection to find
4844		// all of the dependencies. Without this, there would be no way to use `@import` to
4845		// access dependencies by name, since `@import` requires string literals.
4846		var dependencies_source = std.ArrayList(u8).init(gpa);
4847		defer dependencies_source.deinit();
4848
4849		var all_modules: Package.AllModules = .{};
4850		defer all_modules.deinit(gpa);
4851
4852		var wip_errors: std.zig.ErrorBundle.Wip = undefined;
4853		try wip_errors.init(gpa);
4854		defer wip_errors.deinit();
4855
4856	4841	var progress: std.Progress = .{ .dont_print_on_dumb = true };
4857	4842	const root_prog_node = progress.start("Fetch Packages", 0);
4858	4843	defer root_prog_node.end();
4859	4844
4860		// Here we borrow main package's table and will replace it with a fresh
4861		// one after this process completes.
4862		const fetch_result = build_mod.fetchAndAddDependencies(
4863		&main_mod,
4864		arena,
4865		&thread_pool,
4866		&http_client,
4867		build_directory,
4868		global_cache_directory,
4869		local_cache_directory,
4870		&dependencies_source,
4871		&wip_errors,
4872		&all_modules,
4873		root_prog_node,
4874		null,
4875		);
4876		if (wip_errors.root_list.items.len > 0) {
4877		var errors = try wip_errors.toOwnedBundle("");
4878		defer errors.deinit(gpa);
	4845	var job_queue: Package.Fetch.JobQueue = .{
	4846	.http_client = &http_client,
	4847	.thread_pool = &thread_pool,
	4848	.global_cache = global_cache_directory,
	4849	.recursive = true,
	4850	.work_around_btrfs_bug = work_around_btrfs_bug,
	4851	};
	4852	defer job_queue.deinit();
	4853
	4854	try job_queue.all_fetches.ensureUnusedCapacity(gpa, 1);
	4855
	4856	var fetch: Package.Fetch = .{
	4857	.arena = std.heap.ArenaAllocator.init(gpa),
	4858	.location = .{ .relative_path = "" },
	4859	.location_tok = 0,
	4860	.hash_tok = 0,
	4861	.parent_package_root = build_mod.root,
	4862	.parent_manifest_ast = null,
	4863	.prog_node = root_prog_node,
	4864	.job_queue = &job_queue,
	4865	.omit_missing_hash_error = true,
	4866	.allow_missing_paths_field = true,
	4867
	4868	.package_root = undefined,
	4869	.error_bundle = undefined,
	4870	.manifest = null,
	4871	.manifest_ast = undefined,
	4872	.actual_hash = undefined,
	4873	.has_build_zig = false,
	4874	.oom_flag = false,
	4875	};
	4876	job_queue.all_fetches.appendAssumeCapacity(&fetch);
	4877
	4878	job_queue.wait_group.start();
	4879	try job_queue.thread_pool.spawn(Package.Fetch.workerRun, .{&fetch});
	4880	job_queue.wait_group.wait();
	4881
	4882	try job_queue.consolidateErrors();
	4883
	4884	if (fetch.error_bundle.root_list.items.len > 0) {
	4885	var errors = try fetch.error_bundle.toOwnedBundle("");
4879	4886	errors.renderToStdErr(renderOptions(color));
4880	4887	process.exit(1);
4881	4888	}
4882		try fetch_result;
4883	4889
4884		const deps_pkg = try Package.createFilePkg(
4885		gpa,
	4890	const deps_mod = try job_queue.createDependenciesModule(
	4891	arena,
4886	4892	local_cache_directory,
4887	4893	"dependencies.zig",
4888		dependencies_source.items,
4889	4894	);
4890
4891		mem.swap(Package.Table, &main_mod.table, &deps_pkg.table);
4892		try main_mod.add(gpa, "@dependencies", deps_pkg);
	4895	try main_mod.deps.put(arena, "@dependencies", deps_mod);
4893	4896	}
4894		try main_mod.add(gpa, "@build", &build_mod);
	4897	try main_mod.deps.put(arena, "@build", &build_mod);
4895	4898
4896	4899	const comp = Compilation.create(gpa, .{
4897	4900	.zig_lib_directory = zig_lib_directory,

src/musl.zig+1-1

...	...	@@ -206,7 +206,7 @@ pub fn buildCRTFile(comp: Compilation, crt_file: CRTFile, prog_node: std.Progr
206	206	.zig_lib_directory = comp.zig_lib_directory,
207	207	.target = target,
208	208	.root_name = "c",
209		.main_pkg = null,
	209	.main_mod = null,
210	210	.output_mode = .Lib,
211	211	.link_mode = .Dynamic,
212	212	.thread_pool = comp.thread_pool,

author	Andrew Kelley <andrew@ziglang.org> 2023-10-06 21:29:08-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-10-08 16:54:31-07:00
log	f708c5fafc5087a2518e0dc7acf986b59673dddd
tree	0520ae635c4a0b643ba9b33cb6fcdf1ff08e115e
parent	1c0d6f9c0020188326560e058baf36b8034d76e5

CLI: finish updating module API usage