Commit 482b995a4963e045860c7fb1a4e11c48cf4de880 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-04-08 19:05:05-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-04-08 19:05:05-07:00
log	482b995a4963e045860c7fb1a4e11c48cf4de880
tree	e00079980426580bbefd547e879d890dab842511
parent	b9e508c410cd077d704a73418281f6d7839df241

stage2: blaze the trail for std lib integration

This branch adds "builtin" and "std" to the import table when using the
self-hosted backend.

"builtin" gains one additional item:

```
pub const zig_is_stage2 = true; // false when using stage1 backend
```

This allows the std lib to do conditional compilation based on detecting
which backend is being used. This will be removed from builtin as soon
as self-hosted catches up to feature parity with stage1.
Keep a sharp eye out - people are going to be tempted to abuse this.
The general rule of thumb is do not use `builtin.zig_is_stage2`. However
this commit breaks the rule so that we can gain limited start.zig support
as we incrementally improve the self-hosted compiler.

This commit also implements `fullyQualifiedNameHash` and related
functionality, which effectively puts all Decls in their proper
namespaces. `fullyQualifiedName` is not yet implemented.

Stop printing "todo" log messages for test decls unless we are in test
mode.

Add "previous definition here" error notes for Decl name collisions.

This commit does not bring us yet to a newly passing test case.

Here's what I'm working towards:

```zig
const std = @import("std");

export fn main() c_int {
    const a = std.fs.base64_alphabet[0];
    return a - 'A';
}
```

Current output:

```
$ ./zig-cache/bin/zig build-exe test.zig
test.zig:3:1: error: TODO implement more analyze elemptr
zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty
```

So the next steps are clear:
 * Sema: improve elemptr
 * AstGen: implement structInitExpr

10 files changed, 274 insertions(+), 151 deletions(-)

lib
- std
src
- Compilation.zig
- Module.zig
- Package.zig
- Sema.zig
- main.zig
- stage1
  - codegen.cpp

lib/std/start.zig+89-27

...	...	@@ -7,7 +7,7 @@
7	7
8	8	const root = @import("root");
9	9	const std = @import("std.zig");
10		const builtin = std.builtin;
	10	const builtin = @import("builtin");
11	11	const assert = std.debug.assert;
12	12	const uefi = std.os.uefi;
13	13	const tlcsprng = @import("crypto/tlcsprng.zig");
...	...	@@ -17,39 +17,101 @@ var argc_argv_ptr: [*]usize = undefined;
17	17	const start_sym_name = if (builtin.arch.isMIPS()) "__start" else "_start";
18	18
19	19	comptime {
20		if (builtin.output_mode == .Lib and builtin.link_mode == .Dynamic) {
21		if (builtin.os.tag == .windows and !@hasDecl(root, "_DllMainCRTStartup")) {
22		@export(_DllMainCRTStartup, .{ .name = "_DllMainCRTStartup" });
	20	// The self-hosted compiler is not fully capable of handling all of this start.zig file.
	21	// Until then, we have simplified logic here for self-hosted. TODO remove this once
	22	// self-hosted is capable enough to handle all of the real start.zig logic.
	23	if (builtin.zig_is_stage2) {
	24	if (builtin.output_mode == .Exe) {
	25	if (builtin.link_libc or builtin.object_format == .c) {
	26	if (!@hasDecl(root, "main")) {
	27	@export(main2, "main");
	28	}
	29	} else {
	30	if (!@hasDecl(root, "_start")) {
	31	@export(_start2, "_start");
	32	}
	33	}
23	34	}
24		} else if (builtin.output_mode == .Exe or @hasDecl(root, "main")) {
25		if (builtin.link_libc and @hasDecl(root, "main")) {
26		if (@typeInfo(@TypeOf(root.main)).Fn.calling_convention != .C) {
27		@export(main, .{ .name = "main", .linkage = .Weak });
	35	} else {
	36	if (builtin.output_mode == .Lib and builtin.link_mode == .Dynamic) {
	37	if (builtin.os.tag == .windows and !@hasDecl(root, "_DllMainCRTStartup")) {
	38	@export(_DllMainCRTStartup, .{ .name = "_DllMainCRTStartup" });
28	39	}
29		} else if (builtin.os.tag == .windows) {
30		if (!@hasDecl(root, "WinMain") and !@hasDecl(root, "WinMainCRTStartup") and
31		!@hasDecl(root, "wWinMain") and !@hasDecl(root, "wWinMainCRTStartup"))
32		{
33		@export(WinStartup, .{ .name = "wWinMainCRTStartup" });
34		} else if (@hasDecl(root, "WinMain") and !@hasDecl(root, "WinMainCRTStartup") and
35		!@hasDecl(root, "wWinMain") and !@hasDecl(root, "wWinMainCRTStartup"))
36		{
37		@compileError("WinMain not supported; declare wWinMain or main instead");
38		} else if (@hasDecl(root, "wWinMain") and !@hasDecl(root, "wWinMainCRTStartup") and
39		!@hasDecl(root, "WinMain") and !@hasDecl(root, "WinMainCRTStartup"))
40		{
41		@export(wWinMainCRTStartup, .{ .name = "wWinMainCRTStartup" });
	40	} else if (builtin.output_mode == .Exe or @hasDecl(root, "main")) {
	41	if (builtin.link_libc and @hasDecl(root, "main")) {
	42	if (@typeInfo(@TypeOf(root.main)).Fn.calling_convention != .C) {
	43	@export(main, .{ .name = "main", .linkage = .Weak });
	44	}
	45	} else if (builtin.os.tag == .windows) {
	46	if (!@hasDecl(root, "WinMain") and !@hasDecl(root, "WinMainCRTStartup") and
	47	!@hasDecl(root, "wWinMain") and !@hasDecl(root, "wWinMainCRTStartup"))
	48	{
	49	@export(WinStartup, .{ .name = "wWinMainCRTStartup" });
	50	} else if (@hasDecl(root, "WinMain") and !@hasDecl(root, "WinMainCRTStartup") and
	51	!@hasDecl(root, "wWinMain") and !@hasDecl(root, "wWinMainCRTStartup"))
	52	{
	53	@compileError("WinMain not supported; declare wWinMain or main instead");
	54	} else if (@hasDecl(root, "wWinMain") and !@hasDecl(root, "wWinMainCRTStartup") and
	55	!@hasDecl(root, "WinMain") and !@hasDecl(root, "WinMainCRTStartup"))
	56	{
	57	@export(wWinMainCRTStartup, .{ .name = "wWinMainCRTStartup" });
	58	}
	59	} else if (builtin.os.tag == .uefi) {
	60	if (!@hasDecl(root, "EfiMain")) @export(EfiMain, .{ .name = "EfiMain" });
	61	} else if (builtin.arch.isWasm() and builtin.os.tag == .freestanding) {
	62	if (!@hasDecl(root, start_sym_name)) @export(wasm_freestanding_start, .{ .name = start_sym_name });
	63	} else if (builtin.os.tag != .other and builtin.os.tag != .freestanding) {
	64	if (!@hasDecl(root, start_sym_name)) @export(_start, .{ .name = start_sym_name });
42	65	}
43		} else if (builtin.os.tag == .uefi) {
44		if (!@hasDecl(root, "EfiMain")) @export(EfiMain, .{ .name = "EfiMain" });
45		} else if (builtin.arch.isWasm() and builtin.os.tag == .freestanding) {
46		if (!@hasDecl(root, start_sym_name)) @export(wasm_freestanding_start, .{ .name = start_sym_name });
47		} else if (builtin.os.tag != .other and builtin.os.tag != .freestanding) {
48		if (!@hasDecl(root, start_sym_name)) @export(_start, .{ .name = start_sym_name });
49	66	}
50	67	}
51	68	}
52	69
	70	// Simplified start code for stage2 until it supports more language features ///
	71
	72	fn main2() callconv(.C) c_int {
	73	root.main();
	74	return 0;
	75	}
	76
	77	fn _start2() callconv(.Naked) noreturn {
	78	root.main();
	79	exit2(0);
	80	}
	81
	82	fn exit2(code: u8) noreturn {
	83	switch (builtin.arch) {
	84	.x86_64 => {
	85	asm volatile ("syscall"
	86	:
	87	: [number] "{rax}" (231),
	88	[arg1] "{rdi}" (code)
	89	: "rcx", "r11", "memory"
	90	);
	91	},
	92	.arm => {
	93	asm volatile ("svc #0"
	94	:
	95	: [number] "{r7}" (1),
	96	[arg1] "{r0}" (code)
	97	: "memory"
	98	);
	99	},
	100	.aarch64 => {
	101	asm volatile ("svc #0"
	102	:
	103	: [number] "{x8}" (93),
	104	[arg1] "{x0}" (code)
	105	: "memory", "cc"
	106	);
	107	},
	108	else => @compileError("TODO"),
	109	}
	110	unreachable;
	111	}
	112
	113	////////////////////////////////////////////////////////////////////////////////
	114
53	115	fn _DllMainCRTStartup(
54	116	hinstDLL: std.os.windows.HINSTANCE,
55	117	fdwReason: std.os.windows.DWORD,

lib/std/start2.zig deleted-58

...	...	@@ -1,58 +0,0 @@
1		const root = @import("root");
2		const builtin = @import("builtin");
3
4		comptime {
5		if (builtin.output_mode == 0) { // OutputMode.Exe
6		if (builtin.link_libc or builtin.object_format == 5) { // ObjectFormat.c
7		if (!@hasDecl(root, "main")) {
8		@export(otherMain, "main");
9		}
10		} else {
11		if (!@hasDecl(root, "_start")) {
12		@export(otherStart, "_start");
13		}
14		}
15		}
16		}
17
18		// FIXME: Cannot call this function `main`, because `fully qualified names`
19		// have not been implemented yet.
20		fn otherMain() callconv(.C) c_int {
21		root.zigMain();
22		return 0;
23		}
24
25		// FIXME: Cannot call this function `_start`, because `fully qualified names`
26		// have not been implemented yet.
27		fn otherStart() callconv(.Naked) noreturn {
28		root.zigMain();
29		otherExit();
30		}
31
32		// FIXME: Cannot call this function `exit`, because `fully qualified names`
33		// have not been implemented yet.
34		fn otherExit() noreturn {
35		if (builtin.arch == 31) { // x86_64
36		asm volatile ("syscall"
37		:
38		: [number] "{rax}" (231),
39		[arg1] "{rdi}" (0)
40		: "rcx", "r11", "memory"
41		);
42		} else if (builtin.arch == 0) { // arm
43		asm volatile ("svc #0"
44		:
45		: [number] "{r7}" (1),
46		[arg1] "{r0}" (0)
47		: "memory"
48		);
49		} else if (builtin.arch == 2) { // aarch64
50		asm volatile ("svc #0"
51		:
52		: [number] "{x8}" (93),
53		[arg1] "{x0}" (0)
54		: "memory", "cc"
55		);
56		} else @compileError("not yet supported!");
57		unreachable;
58		}

lib/std/std.zig+1-1

...	...	@@ -92,7 +92,7 @@ pub const zig = @import("zig.zig");
92	92	pub const start = @import("start.zig");
93	93
94	94	// This forces the start.zig file to be imported, and the comptime logic inside that
95		// file decides whether to export any appropriate start symbols.
	95	// file decides whether to export any appropriate start symbols, and call main.
96	96	comptime {
97	97	_ = start;
98	98	}

lib/std/zig.zig+11-8

...	...	@@ -18,16 +18,19 @@ pub const CrossTarget = @import("zig/cross_target.zig").CrossTarget;
18	18
19	19	pub const SrcHash = [16]u8;
20	20
21		/// If the source is small enough, it is used directly as the hash.
22		/// If it is long, blake3 hash is computed.
23	21	pub fn hashSrc(src: []const u8) SrcHash {
24	22	var out: SrcHash = undefined;
25		if (src.len <= @typeInfo(SrcHash).Array.len) {
26		std.mem.copy(u8, &out, src);
27		std.mem.set(u8, out[src.len..], 0);
28		} else {
29		std.crypto.hash.Blake3.hash(src, &out, .{});
30		}
	23	std.crypto.hash.Blake3.hash(src, &out, .{});
	24	return out;
	25	}
	26
	27	pub fn hashName(parent_hash: SrcHash, sep: []const u8, name: []const u8) SrcHash {
	28	var out: SrcHash = undefined;
	29	var hasher = std.crypto.hash.Blake3.init(.{});
	30	hasher.update(&parent_hash);
	31	hasher.update(sep);
	32	hasher.update(name);
	33	hasher.final(&out);
31	34	return out;
32	35	}
33	36

src/Compilation.zig+59-30

...	...	@@ -906,38 +906,61 @@ pub fn create(gpa: Allocator, options: InitOptions) !Compilation {
906	906	artifact_sub_dir,
907	907	};
908	908
909		// TODO when we implement serialization and deserialization of incremental compilation metadata,
910		// this is where we would load it. We have open a handle to the directory where
911		// the output either already is, or will be.
	909	// If we rely on stage1, we must not redundantly add these packages.
	910	const use_stage1 = build_options.is_stage1 and use_llvm;
	911	if (!use_stage1) {
	912	const builtin_pkg = try Package.createWithDir(
	913	gpa,
	914	zig_cache_artifact_directory,
	915	null,
	916	"builtin.zig",
	917	);
	918	errdefer builtin_pkg.destroy(gpa);
	919
	920	const std_pkg = try Package.createWithDir(
	921	gpa,
	922	options.zig_lib_directory,
	923	"std",
	924	"std.zig",
	925	);
	926	errdefer std_pkg.destroy(gpa);
	927
	928	try root_pkg.addAndAdopt(gpa, "builtin", builtin_pkg);
	929	try root_pkg.add(gpa, "root", root_pkg);
	930	try root_pkg.addAndAdopt(gpa, "std", std_pkg);
	931
	932	try std_pkg.add(gpa, "builtin", builtin_pkg);
	933	try std_pkg.add(gpa, "root", root_pkg);
	934	}
	935
	936	// TODO when we implement serialization and deserialization of incremental
	937	// compilation metadata, this is where we would load it. We have open a handle
	938	// to the directory where the output either already is, or will be.
912	939	// However we currently do not have serialization of such metadata, so for now
913	940	// we set up an empty Module that does the entire compilation fresh.
914	941
915		const root_scope = rs: {
916		if (mem.endsWith(u8, root_pkg.root_src_path, ".zig")) {
917		const root_scope = try gpa.create(Module.Scope.File);
918		const struct_ty = try Type.Tag.empty_struct.create(
919		gpa,
920		&root_scope.root_container,
921		);
922		root_scope.* = .{
923		// TODO this is duped so it can be freed in Container.deinit
924		.sub_file_path = try gpa.dupe(u8, root_pkg.root_src_path),
925		.source = .{ .unloaded = {} },
926		.tree = undefined,
927		.status = .never_loaded,
928		.pkg = root_pkg,
929		.root_container = .{
930		.file_scope = root_scope,
931		.decls = .{},
932		.ty = struct_ty,
933		},
934		};
935		break :rs root_scope;
936		} else if (mem.endsWith(u8, root_pkg.root_src_path, ".zir")) {
937		return error.ZirFilesUnsupported;
938		} else {
939		unreachable;
940		}
	942	// TODO remove CLI support for .zir files and then we can remove this error
	943	// handling and assertion.
	944	if (mem.endsWith(u8, root_pkg.root_src_path, ".zir")) return error.ZirFilesUnsupported;
	945	assert(mem.endsWith(u8, root_pkg.root_src_path, ".zig"));
	946
	947	const root_scope = try gpa.create(Module.Scope.File);
	948	errdefer gpa.destroy(root_scope);
	949
	950	const struct_ty = try Type.Tag.empty_struct.create(gpa, &root_scope.root_container);
	951	root_scope.* = .{
	952	// TODO this is duped so it can be freed in Container.deinit
	953	.sub_file_path = try gpa.dupe(u8, root_pkg.root_src_path),
	954	.source = .{ .unloaded = {} },
	955	.tree = undefined,
	956	.status = .never_loaded,
	957	.pkg = root_pkg,
	958	.root_container = .{
	959	.file_scope = root_scope,
	960	.decls = .{},
	961	.ty = struct_ty,
	962	.parent_name_hash = root_pkg.namespace_hash,
	963	},
941	964	};
942	965
943	966	const module = try arena.create(Module);
...	...	@@ -1339,7 +1362,8 @@ pub fn update(self: *Compilation) !void {
1339	1362	self.c_object_work_queue.writeItemAssumeCapacity(entry.key);
1340	1363	}
1341	1364
1342		const use_stage1 = build_options.omit_stage2 or build_options.is_stage1 and self.bin_file.options.use_llvm;
	1365	const use_stage1 = build_options.omit_stage2 or
	1366	(build_options.is_stage1 and self.bin_file.options.use_llvm);
1343	1367	if (!use_stage1) {
1344	1368	if (self.bin_file.options.module) \|module\| {
1345	1369	module.compile_log_text.shrinkAndFree(module.gpa, 0);
...	...	@@ -2840,6 +2864,8 @@ pub fn generateBuiltinZigSource(comp: Compilation, allocator: Allocator) ![]u8
2840	2864
2841	2865	const target = comp.getTarget();
2842	2866	const generic_arch_name = target.cpu.arch.genericName();
	2867	const use_stage1 = build_options.omit_stage2 or
	2868	(build_options.is_stage1 and comp.bin_file.options.use_llvm);
2843	2869
2844	2870	@setEvalBranchQuota(4000);
2845	2871	try buffer.writer().print(
...	...	@@ -2852,6 +2878,7 @@ pub fn generateBuiltinZigSource(comp: Compilation, allocator: Allocator) ![]u8
2852	2878	\\/// Zig version. When writing code that supports multiple versions of Zig, prefer
2853	2879	\\/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
2854	2880	\\pub const zig_version = try @import("std").SemanticVersion.parse("{s}");
	2881	\\pub const zig_is_stage2 = {};
2855	2882	\\
2856	2883	\\pub const output_mode = OutputMode.{};
2857	2884	\\pub const link_mode = LinkMode.{};
...	...	@@ -2865,6 +2892,7 @@ pub fn generateBuiltinZigSource(comp: Compilation, allocator: Allocator) ![]u8
2865	2892	\\
2866	2893	, .{
2867	2894	build_options.version,
	2895	!use_stage1,
2868	2896	std.zig.fmtId(@tagName(comp.bin_file.options.output_mode)),
2869	2897	std.zig.fmtId(@tagName(comp.bin_file.options.link_mode)),
2870	2898	comp.bin_file.options.is_test,
...	...	@@ -3074,6 +3102,7 @@ fn buildOutputFromZig(
3074	3102	.handle = special_dir,
3075	3103	},
3076	3104	.root_src_path = src_basename,
	3105	.namespace_hash = Package.root_namespace_hash,
3077	3106	};
3078	3107	const root_name = src_basename[0 .. src_basename.len - std.fs.path.extension(src_basename).len];
3079	3108	const target = comp.getTarget();

src/Module.zig+11-6

...	...	@@ -678,6 +678,7 @@ pub const Scope = struct {
678	678	base: Scope = Scope{ .tag = base_tag },
679	679
680	680	file_scope: *Scope.File,
	681	parent_name_hash: NameHash,
681	682
682	683	/// Direct children of the file.
683	684	decls: std.AutoArrayHashMapUnmanaged(*Decl, void) = .{},
...	...	@@ -696,8 +697,7 @@ pub const Scope = struct {
696	697	}
697	698
698	699	pub fn fullyQualifiedNameHash(cont: *Container, name: []const u8) NameHash {
699		// TODO container scope qualified names.
700		return std.zig.hashSrc(name);
	700	return std.zig.hashName(cont.parent_name_hash, ".", name);
701	701	}
702	702
703	703	pub fn renderFullyQualifiedName(cont: Container, name: []const u8, writer: anytype) !void {
...	...	@@ -2513,6 +2513,7 @@ fn astgenAndSemaDecl(mod: Module, decl: Decl) !bool {
2513	2513
2514	2514	const block_expr = node_datas[decl_node].lhs;
2515	2515	_ = try AstGen.comptimeExpr(&gen_scope, &gen_scope.base, .none, block_expr);
	2516	_ = try gen_scope.addBreak(.break_inline, 0, .void_value);
2516	2517
2517	2518	const code = try gen_scope.finish();
2518	2519	if (std.builtin.mode == .Debug and mod.comp.verbose_ir) {
...	...	@@ -3468,7 +3469,9 @@ pub fn analyzeContainer(mod: Module, container_scope: Scope.Container) !void {
3468	3469	),
3469	3470
3470	3471	.test_decl => {
3471		log.err("TODO: analyze test decl", .{});
	3472	if (mod.comp.bin_file.options.is_test) {
	3473	log.err("TODO: analyze test decl", .{});
	3474	}
3472	3475	},
3473	3476	.@"usingnamespace" => {
3474	3477	log.err("TODO: analyze usingnamespace decl", .{});
...	...	@@ -3532,6 +3535,7 @@ fn semaContainerFn(
3532	3535	.lazy = .{ .token_abs = name_tok },
3533	3536	}, "redefinition of '{s}'", .{decl.name});
3534	3537	errdefer msg.destroy(mod.gpa);
	3538	try mod.errNoteNonLazy(decl.srcLoc(), msg, "previous definition here", .{});
3535	3539	try mod.failed_decls.putNoClobber(mod.gpa, decl, msg);
3536	3540	} else {
3537	3541	if (!srcHashEql(decl.contents_hash, contents_hash)) {
...	...	@@ -3589,12 +3593,13 @@ fn semaContainerVar(
3589	3593	decl.src_index = decl_i;
3590	3594	if (deleted_decls.swapRemove(decl) == null) {
3591	3595	decl.analysis = .sema_failure;
3592		const err_msg = try ErrorMsg.create(mod.gpa, .{
	3596	const msg = try ErrorMsg.create(mod.gpa, .{
3593	3597	.container = .{ .file_scope = container_scope.file_scope },
3594	3598	.lazy = .{ .token_abs = name_token },
3595	3599	}, "redefinition of '{s}'", .{decl.name});
3596		errdefer err_msg.destroy(mod.gpa);
3597		try mod.failed_decls.putNoClobber(mod.gpa, decl, err_msg);
	3600	errdefer msg.destroy(mod.gpa);
	3601	try mod.errNoteNonLazy(decl.srcLoc(), msg, "previous definition here", .{});
	3602	try mod.failed_decls.putNoClobber(mod.gpa, decl, msg);
3598	3603	} else if (!srcHashEql(decl.contents_hash, contents_hash)) {
3599	3604	try outdated_decls.put(decl, {});
3600	3605	decl.contents_hash = contents_hash;

src/Package.zig+68-8

...	...	@@ -4,18 +4,29 @@ const std = @import("std");
4	4	const fs = std.fs;
5	5	const mem = std.mem;
6	6	const Allocator = mem.Allocator;
	7	const assert = std.debug.assert;
7	8
8	9	const Compilation = @import("Compilation.zig");
	10	const Module = @import("Module.zig");
9	11
10	12	pub const Table = std.StringHashMapUnmanaged(*Package);
11	13
	14	pub const root_namespace_hash: Module.Scope.NameHash = .{
	15	0, 0, 6, 6, 6, 0, 0, 0,
	16	6, 9, 0, 0, 0, 4, 2, 0,
	17	};
	18
12	19	root_src_directory: Compilation.Directory,
13	20	/// Relative to `root_src_directory`. May contain path separators.
14	21	root_src_path: []const u8,
15	22	table: Table = .{},
16	23	parent: ?*Package = null,
	24	namespace_hash: Module.Scope.NameHash,
	25	/// Whether to free `root_src_directory` on `destroy`.
	26	root_src_directory_owned: bool = false,
17	27
18	28	/// Allocate a Package. No references to the slices passed are kept.
	29	/// Don't forget to set `namespace_hash` later.
19	30	pub fn create(
20	31	gpa: *Allocator,
21	32	/// Null indicates the current working directory
...	...	@@ -38,27 +49,69 @@ pub fn create(
38	49	.handle = if (owned_dir_path) \|p\| try fs.cwd().openDir(p, .{}) else fs.cwd(),
39	50	},
40	51	.root_src_path = owned_src_path,
	52	.root_src_directory_owned = true,
	53	.namespace_hash = undefined,
41	54	};
42	55
43	56	return ptr;
44	57	}
45	58
46		/// Free all memory associated with this package and recursively call destroy
47		/// on all packages in its table
	59	pub fn createWithDir(
	60	gpa: *Allocator,
	61	directory: Compilation.Directory,
	62	/// Relative to `directory`. If null, means `directory` is the root src dir
	63	/// and is owned externally.
	64	root_src_dir_path: ?[]const u8,
	65	/// Relative to root_src_dir_path
	66	root_src_path: []const u8,
	67	) !*Package {
	68	const ptr = try gpa.create(Package);
	69	errdefer gpa.destroy(ptr);
	70
	71	const owned_src_path = try gpa.dupe(u8, root_src_path);
	72	errdefer gpa.free(owned_src_path);
	73
	74	if (root_src_dir_path) \|p\| {
	75	const owned_dir_path = try directory.join(gpa, &[1][]const u8{p});
	76	errdefer gpa.free(owned_dir_path);
	77
	78	ptr.* = .{
	79	.root_src_directory = .{
	80	.path = owned_dir_path,
	81	.handle = try directory.handle.openDir(p, .{}),
	82	},
	83	.root_src_directory_owned = true,
	84	.root_src_path = owned_src_path,
	85	.namespace_hash = undefined,
	86	};
	87	} else {
	88	ptr.* = .{
	89	.root_src_directory = directory,
	90	.root_src_directory_owned = false,
	91	.root_src_path = owned_src_path,
	92	.namespace_hash = undefined,
	93	};
	94	}
	95	return ptr;
	96	}
	97
	98	/// Free all memory associated with this package. It does not destroy any packages
	99	/// inside its table; the caller is responsible for calling destroy() on them.
48	100	pub fn destroy(pkg: Package, gpa: Allocator) void {
49	101	gpa.free(pkg.root_src_path);
50	102
51		// If root_src_directory.path is null then the handle is the cwd()
52		// which shouldn't be closed.
53		if (pkg.root_src_directory.path) \|p\| {
54		gpa.free(p);
55		pkg.root_src_directory.handle.close();
	103	if (pkg.root_src_directory_owned) {
	104	// If root_src_directory.path is null then the handle is the cwd()
	105	// which shouldn't be closed.
	106	if (pkg.root_src_directory.path) \|p\| {
	107	gpa.free(p);
	108	pkg.root_src_directory.handle.close();
	109	}
56	110	}
57	111
58	112	{
59	113	var it = pkg.table.iterator();
60	114	while (it.next()) \|kv\| {
61		kv.value.destroy(gpa);
62	115	gpa.free(kv.key);
63	116	}
64	117	}
...	...	@@ -72,3 +125,10 @@ pub fn add(pkg: Package, gpa: Allocator, name: []const u8, package: *Package)
72	125	const name_dupe = try mem.dupe(gpa, u8, name);
73	126	pkg.table.putAssumeCapacityNoClobber(name_dupe, package);
74	127	}
	128
	129	pub fn addAndAdopt(parent: Package, gpa: Allocator, name: []const u8, child: *Package) !void {
	130	assert(child.parent == null); // make up your mind, who is the parent??
	131	child.parent = parent;
	132	child.namespace_hash = std.zig.hashName(parent.namespace_hash, ":", name);
	133	return parent.add(gpa, name, child);
	134	}

src/Sema.zig+13-6

...	...	@@ -598,6 +598,10 @@ fn zirStructDecl(
598	598	const struct_obj = try new_decl_arena.allocator.create(Module.Struct);
599	599	const struct_ty = try Type.Tag.@"struct".create(&new_decl_arena.allocator, struct_obj);
600	600	const struct_val = try Value.Tag.ty.create(&new_decl_arena.allocator, struct_ty);
	601	const new_decl = try sema.mod.createAnonymousDecl(&block.base, &new_decl_arena, .{
	602	.ty = Type.initTag(.type),
	603	.val = struct_val,
	604	});
601	605	struct_obj.* = .{
602	606	.owner_decl = sema.owner_decl,
603	607	.fields = fields_map,
...	...	@@ -605,12 +609,9 @@ fn zirStructDecl(
605	609	.container = .{
606	610	.ty = struct_ty,
607	611	.file_scope = block.getFileScope(),
	612	.parent_name_hash = new_decl.fullyQualifiedNameHash(),
608	613	},
609	614	};
610		const new_decl = try sema.mod.createAnonymousDecl(&block.base, &new_decl_arena, .{
611		.ty = Type.initTag(.type),
612		.val = struct_val,
613		});
614	615	return sema.analyzeDeclVal(block, src, new_decl);
615	616	}
616	617
...	...	@@ -5298,9 +5299,9 @@ fn analyzeImport(sema: Sema, block: Scope.Block, src: LazySrcLoc, target_strin
5298	5299	try std.fs.path.resolve(sema.gpa, &[_][]const u8{ cur_pkg_dir_path, target_string });
5299	5300	errdefer sema.gpa.free(resolved_path);
5300	5301
5301		if (sema.mod.import_table.get(resolved_path)) \|some\| {
	5302	if (sema.mod.import_table.get(resolved_path)) \|cached_import\| {
5302	5303	sema.gpa.free(resolved_path);
5303		return some;
	5304	return cached_import;
5304	5305	}
5305	5306
5306	5307	if (found_pkg == null) {
...	...	@@ -5318,6 +5319,11 @@ fn analyzeImport(sema: Sema, block: Scope.Block, src: LazySrcLoc, target_strin
5318	5319	const struct_ty = try Type.Tag.empty_struct.create(sema.gpa, &file_scope.root_container);
5319	5320	errdefer sema.gpa.destroy(struct_ty.castTag(.empty_struct).?);
5320	5321
	5322	const container_name_hash: Scope.NameHash = if (found_pkg) \|pkg\|
	5323	pkg.namespace_hash
	5324	else
	5325	std.zig.hashName(cur_pkg.namespace_hash, "/", resolved_path);
	5326
5321	5327	file_scope.* = .{
5322	5328	.sub_file_path = resolved_path,
5323	5329	.source = .{ .unloaded = {} },
...	...	@@ -5328,6 +5334,7 @@ fn analyzeImport(sema: Sema, block: Scope.Block, src: LazySrcLoc, target_strin
5328	5334	.file_scope = file_scope,
5329	5335	.decls = .{},
5330	5336	.ty = struct_ty,
	5337	.parent_name_hash = container_name_hash,
5331	5338	},
5332	5339	};
5333	5340	sema.mod.analyzeContainer(&file_scope.root_container) catch \|err\| switch (err) {

src/main.zig+21-7

...	...	@@ -599,15 +599,15 @@ fn buildOutputType(
599	599	var test_exec_args = std.ArrayList(?[]const u8).init(gpa);
600	600	defer test_exec_args.deinit();
601	601
602		const pkg_tree_root = try gpa.create(Package);
603	602	// This package only exists to clean up the code parsing --pkg-begin and
604	603	// --pkg-end flags. Use dummy values that are safe for the destroy call.
605		pkg_tree_root.* = .{
	604	var pkg_tree_root: Package = .{
606	605	.root_src_directory = .{ .path = null, .handle = fs.cwd() },
607	606	.root_src_path = &[0]u8{},
	607	.namespace_hash = Package.root_namespace_hash,
608	608	};
609		defer pkg_tree_root.destroy(gpa);
610		var cur_pkg: *Package = pkg_tree_root;
	609	defer freePkgTree(gpa, &pkg_tree_root, false);
	610	var cur_pkg: *Package = &pkg_tree_root;
611	611
612	612	switch (arg_mode) {
613	613	.build, .translate_c, .zig_test, .run => {
...	...	@@ -658,8 +658,7 @@ fn buildOutputType(
658	658	) catch \|err\| {
659	659	fatal("Failed to add package at path {s}: {s}", .{ pkg_path, @errorName(err) });
660	660	};
661		new_cur_pkg.parent = cur_pkg;
662		try cur_pkg.add(gpa, pkg_name, new_cur_pkg);
	661	try cur_pkg.addAndAdopt(gpa, pkg_name, new_cur_pkg);
663	662	cur_pkg = new_cur_pkg;
664	663	} else if (mem.eql(u8, arg, "--pkg-end")) {
665	664	cur_pkg = cur_pkg.parent orelse
...	...	@@ -1747,6 +1746,7 @@ fn buildOutputType(
1747	1746	if (root_pkg) \|pkg\| {
1748	1747	pkg.table = pkg_tree_root.table;
1749	1748	pkg_tree_root.table = .{};
	1749	pkg.namespace_hash = pkg_tree_root.namespace_hash;
1750	1750	}
1751	1751
1752	1752	const self_exe_path = try fs.selfExePathAlloc(arena);
...	...	@@ -2151,6 +2151,18 @@ fn updateModule(gpa: Allocator, comp: Compilation, hook: AfterUpdateHook) !voi
2151	2151	}
2152	2152	}
2153	2153
	2154	fn freePkgTree(gpa: Allocator, pkg: Package, free_parent: bool) void {
	2155	{
	2156	var it = pkg.table.iterator();
	2157	while (it.next()) \|kv\| {
	2158	freePkgTree(gpa, kv.value, true);
	2159	}
	2160	}
	2161	if (free_parent) {
	2162	pkg.destroy(gpa);
	2163	}
	2164	}
	2165
2154	2166	fn cmdTranslateC(comp: Compilation, arena: Allocator, enable_cache: bool) !void {
2155	2167	if (!build_options.have_llvm)
2156	2168	fatal("cannot translate-c: compiler built without LLVM extensions", .{});
...	...	@@ -2505,6 +2517,7 @@ pub fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !v
2505	2517	.handle = try zig_lib_directory.handle.openDir(std_special, .{}),
2506	2518	},
2507	2519	.root_src_path = "build_runner.zig",
	2520	.namespace_hash = Package.root_namespace_hash,
2508	2521	};
2509	2522	defer root_pkg.root_src_directory.handle.close();
2510	2523
...	...	@@ -2550,8 +2563,9 @@ pub fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !v
2550	2563	var build_pkg: Package = .{
2551	2564	.root_src_directory = build_directory,
2552	2565	.root_src_path = build_zig_basename,
	2566	.namespace_hash = undefined,
2553	2567	};
2554		try root_pkg.table.put(arena, "@build", &build_pkg);
	2568	try root_pkg.addAndAdopt(arena, "@build", &build_pkg);
2555	2569
2556	2570	var global_cache_directory: Compilation.Directory = l: {
2557	2571	const p = override_global_cache_dir orelse try introspect.resolveGlobalCacheDir(arena);

src/stage1/codegen.cpp+1

...	...	@@ -9137,6 +9137,7 @@ Buf codegen_generate_builtin_source(CodeGen g) {
9137	9137	buf_appendf(contents, "pub const position_independent_executable = %s;\n", bool_to_str(g->have_pie));
9138	9138	buf_appendf(contents, "pub const strip_debug_info = %s;\n", bool_to_str(g->strip_debug_symbols));
9139	9139	buf_appendf(contents, "pub const code_model = CodeModel.default;\n");
	9140	buf_appendf(contents, "pub const zig_is_stage2 = false;\n");
9140	9141
9141	9142	{
9142	9143	TargetSubsystem detected_subsystem = detect_subsystem(g);