Commit 3ae4931dc1a3b1b338d2fd3a49a5a79b445bebf6 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-11-25 17:12:50-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-11-28 01:23:39-05:00
log	3ae4931dc1a3b1b338d2fd3a49a5a79b445bebf6
tree	8c6f031412192a2024f17506a8f9d10e0fd13343
parent	7411be3c9e6d169108456f03b3cbb9b476ee7498

CLI: more careful resolution of paths

In general, we prefer compiler code to use relative paths based on open
directory handles because this is the most portable. However, sometimes
absolute paths are used, and sometimes relative paths are used that go
up a directory.

The recent improvements in 81d2135ca6ebd71b8c121a19957c8fbf7f87125b
regressed the use case when an absolute path is used for the zig lib
directory mixed with a relative path used for the root source file. This
could happen when, for example, running the standard library tests, like
this:

stage3/bin/zig test ../lib/std/std.zig

This happened because the zig lib dir was inferred to be an absolute
directory based on the zig executable directory, while the root source
file was detected as a relative path. There was no common prefix and so
it was not determined that the std.zig file was inside the lib
directory.

This commit adds a function for resolving paths that preserves relative
path names while allowing absolute paths, and converting relative
upwards paths (e.g. "../foo") to absolute paths. This restores the
previous functionality while remaining compatible with systems such as
WASI that cannot deal with absolute paths.

6 files changed, 131 insertions(+), 58 deletions(-)

build.zig
lib
- std
  - fs
    path.zig
src

build.zig+1-1

 @@ -41,9 +41,9 @@ pub fn build(b: *Builder) !void {
     docs_step.dependOn(&docgen_cmd.step);
     const test_cases = b.addTest("src/test.zig");
+    test_cases.main_pkg_path = ".";
     test_cases.stack_size = stack_size;
     test_cases.setBuildMode(mode);
-    test_cases.addPackagePath("test_cases", "test/cases.zig");
     test_cases.single_threaded = single_threaded;
     const fmt_build_zig = b.addFmt(&[_][]const u8{"build.zig"});

lib/std/fs/path.zig+26-25

 @@ -462,7 +462,6 @@ pub fn resolve(allocator: Allocator, paths: []const []const u8) ![]u8 {
 /// This function is like a series of `cd` statements executed one after another.
 /// It resolves "." and "..".
 /// The result does not have a trailing path separator.
-/// If all paths are relative it uses the current working directory as a starting point.
 /// Each drive has its own current working directory.
 /// Path separators are canonicalized to '\\' and drives are canonicalized to capital letters.
 /// Note: all usage of this function should be audited due to the existence of symlinks.
 @@ -572,15 +571,15 @@ pub fn resolveWindows(allocator: Allocator, paths: []const []const u8) ![]u8 {
             continue;
         }
         var it = mem.tokenize(u8, p[parsed.disk_designator.len..], "/\\");
-        component: while (it.next()) |component| {
+        while (it.next()) |component| {
             if (mem.eql(u8, component, ".")) {
                 continue;
             } else if (mem.eql(u8, component, "..")) {
+                if (result.items.len == 0) {
+                    negative_count += 1;
+                    continue;
+                }
                 while (true) {
-                    if (result.items.len == 0) {
-                        negative_count += 1;
-                        continue :component;
-                    }
                     if (result.items.len == disk_designator_len) {
                         break;
                     }
 @@ -589,7 +588,7 @@ pub fn resolveWindows(allocator: Allocator, paths: []const []const u8) ![]u8 {
                         else => false,
                     };
                     result.items.len -= 1;
-                    if (end_with_sep) break;
+                    if (end_with_sep or result.items.len == 0) break;
                 }
             } else if (!have_abs_path and result.items.len == 0) {
                 try result.appendSlice(component);
 @@ -659,18 +658,18 @@ pub fn resolvePosix(allocator: Allocator, paths: []const []const u8) Allocator.E
             result.clearRetainingCapacity();
         }
         var it = mem.tokenize(u8, p, "/");
-        component: while (it.next()) |component| {
+        while (it.next()) |component| {
             if (mem.eql(u8, component, ".")) {
                 continue;
             } else if (mem.eql(u8, component, "..")) {
+                if (result.items.len == 0) {
+                    negative_count += @boolToInt(!is_abs);
+                    continue;
+                }
                 while (true) {
-                    if (result.items.len == 0) {
-                        negative_count += @boolToInt(!is_abs);
-                        continue :component;
-                    }
                     const ends_with_slash = result.items[result.items.len - 1] == '/';
                     result.items.len -= 1;
-                    if (ends_with_slash) break;
+                    if (ends_with_slash or result.items.len == 0) break;
                 }
             } else if (result.items.len > 0 or is_abs) {
                 try result.ensureUnusedCapacity(1 + component.len);
 @@ -717,10 +716,10 @@ pub fn resolvePosix(allocator: Allocator, paths: []const []const u8) Allocator.E
 }
 test "resolve" {
-    try testResolveWindows(&[_][]const u8{ "a\\b\\c\\", "..\\..\\.." }, "..");
+    try testResolveWindows(&[_][]const u8{ "a\\b\\c\\", "..\\..\\.." }, ".");
     try testResolveWindows(&[_][]const u8{"."}, ".");
-    try testResolvePosix(&[_][]const u8{ "a/b/c/", "../../.." }, "..");
+    try testResolvePosix(&[_][]const u8{ "a/b/c/", "../../.." }, ".");
     try testResolvePosix(&[_][]const u8{"."}, ".");
 }
 @@ -753,19 +752,21 @@ test "resolveWindows" {
 }
 test "resolvePosix" {
-    try testResolvePosix(&[_][]const u8{ "/a/b", "c" }, "/a/b/c");
+    try testResolvePosix(&.{ "/a/b", "c" }, "/a/b/c");
-    try testResolvePosix(&[_][]const u8{ "/a/b", "c", "//d", "e///" }, "/d/e");
+    try testResolvePosix(&.{ "/a/b", "c", "//d", "e///" }, "/d/e");
-    try testResolvePosix(&[_][]const u8{ "/a/b/c", "..", "../" }, "/a");
+    try testResolvePosix(&.{ "/a/b/c", "..", "../" }, "/a");
-    try testResolvePosix(&[_][]const u8{ "/", "..", ".." }, "/");
+    try testResolvePosix(&.{ "/", "..", ".." }, "/");
-    try testResolvePosix(&[_][]const u8{"/a/b/c/"}, "/a/b/c");
+    try testResolvePosix(&.{"/a/b/c/"}, "/a/b/c");
-    try testResolvePosix(&[_][]const u8{ "/var/lib", "../", "file/" }, "/var/file");
+    try testResolvePosix(&.{ "/var/lib", "../", "file/" }, "/var/file");
-    try testResolvePosix(&[_][]const u8{ "/var/lib", "/../", "file/" }, "/file");
+    try testResolvePosix(&.{ "/var/lib", "/../", "file/" }, "/file");
-    try testResolvePosix(&[_][]const u8{ "/some/dir", ".", "/absolute/" }, "/absolute");
+    try testResolvePosix(&.{ "/some/dir", ".", "/absolute/" }, "/absolute");
-    try testResolvePosix(&[_][]const u8{ "/foo/tmp.3/", "../tmp.3/cycles/root.js" }, "/foo/tmp.3/cycles/root.js");
+    try testResolvePosix(&.{ "/foo/tmp.3/", "../tmp.3/cycles/root.js" }, "/foo/tmp.3/cycles/root.js");
     // Keep relative paths relative.
-    try testResolvePosix(&[_][]const u8{"a/b"}, "a/b");
+    try testResolvePosix(&.{"a/b"}, "a/b");
+    try testResolvePosix(&.{"."}, ".");
+    try testResolvePosix(&.{ ".", "src/test.zig", "..", "../test/cases.zig" }, "test/cases.zig");
 }
 fn testResolveWindows(paths: []const []const u8, expected: []const u8) !void {

src/Module.zig+25-12

 @@ -30,6 +30,7 @@ const Sema = @import("Sema.zig");
 const target_util = @import("target.zig");
 const build_options = @import("build_options");
 const Liveness = @import("Liveness.zig");
+const isUpDir = @import("introspect.zig").isUpDir;
 /// General-purpose allocator. Used for both temporary and long-term storage.
 gpa: Allocator,
 @@ -4957,15 +4958,19 @@ pub fn importFile(
     const resolved_root_path = try std.fs.path.resolve(gpa, &[_][]const u8{cur_pkg_dir_path});
     defer gpa.free(resolved_root_path);
-    if (!mem.startsWith(u8, resolved_path, resolved_root_path) or
+    const sub_file_path = p: {
-        // This prevents this check from triggering when the name of the
+        if (mem.startsWith(u8, resolved_path, resolved_root_path)) {
-        // imported file starts with the root path's directory name.
+            // +1 for the directory separator here.
-        !std.fs.path.isSep(resolved_path[resolved_root_path.len]))
+            break :p try gpa.dupe(u8, resolved_path[resolved_root_path.len + 1 ..]);
-    {
+        }
+        if (mem.eql(u8, resolved_root_path, ".") and
+            !isUpDir(resolved_path) and
+            !std.fs.path.isAbsolute(resolved_path))
+        {
+            break :p try gpa.dupe(u8, resolved_path);
+        }
         return error.ImportOutsidePkgPath;
-    }
+    };
-    // +1 for the directory separator here.
-    const sub_file_path = try gpa.dupe(u8, resolved_path[resolved_root_path.len + 1 ..]);
     errdefer gpa.free(sub_file_path);
     log.debug("new importFile. resolved_root_path={s}, resolved_path={s}, sub_file_path={s}, import_string={s}", .{
 @@ -5015,11 +5020,19 @@ pub fn embedFile(mod: *Module, cur_file: *File, rel_file_path: []const u8) !*Emb
     const resolved_root_path = try std.fs.path.resolve(gpa, &[_][]const u8{cur_pkg_dir_path});
     defer gpa.free(resolved_root_path);
-    if (!mem.startsWith(u8, resolved_path, resolved_root_path)) {
+    const sub_file_path = p: {
+        if (mem.startsWith(u8, resolved_path, resolved_root_path)) {
+            // +1 for the directory separator here.
+            break :p try gpa.dupe(u8, resolved_path[resolved_root_path.len + 1 ..]);
+        }
+        if (mem.eql(u8, resolved_root_path, ".") and
+            !isUpDir(resolved_path) and
+            !std.fs.path.isAbsolute(resolved_path))
+        {
+            break :p try gpa.dupe(u8, resolved_path);
+        }
         return error.ImportOutsidePkgPath;
-    }
+    };
-    // +1 for the directory separator here.
-    const sub_file_path = try gpa.dupe(u8, resolved_path[resolved_root_path.len + 1 ..]);
     errdefer gpa.free(sub_file_path);
     var file = try cur_file.pkg.root_src_directory.handle.openFile(sub_file_path, .{});

src/introspect.zig+52-2

...	@@ -82,7 +82,12 @@ pub fn findZigLibDir(gpa: mem.Allocator) !Compilation.Directory {	...	@@ -82,7 +82,12 @@ pub fn findZigLibDir(gpa: mem.Allocator) !Compilation.Directory {
82	pub fn findZigLibDirFromSelfExe(	82	pub fn findZigLibDirFromSelfExe(
83	allocator: mem.Allocator,	83	allocator: mem.Allocator,
84	self_exe_path: []const u8,	84	self_exe_path: []const u8,
85	) error{ OutOfMemory, FileNotFound }!Compilation.Directory {	85	) error{
		86	OutOfMemory,
		87	FileNotFound,
		88	CurrentWorkingDirectoryUnlinked,
		89	Unexpected,
		90	}!Compilation.Directory {
86	const cwd = fs.cwd();	91	const cwd = fs.cwd();
87	var cur_path: []const u8 = self_exe_path;	92	var cur_path: []const u8 = self_exe_path;
88	while (fs.path.dirname(cur_path)) \|dirname\| : (cur_path = dirname) {	93	while (fs.path.dirname(cur_path)) \|dirname\| : (cur_path = dirname) {
...	@@ -90,9 +95,11 @@ pub fn findZigLibDirFromSelfExe(	...	@@ -90,9 +95,11 @@ pub fn findZigLibDirFromSelfExe(
90	defer base_dir.close();	95	defer base_dir.close();
91		96
92	const sub_directory = testZigInstallPrefix(base_dir) orelse continue;	97	const sub_directory = testZigInstallPrefix(base_dir) orelse continue;
		98	const p = try fs.path.join(allocator, &[_][]const u8{ dirname, sub_directory.path.? });
		99	defer allocator.free(p);
93	return Compilation.Directory{	100	return Compilation.Directory{
94	.handle = sub_directory.handle,	101	.handle = sub_directory.handle,
95	.path = try fs.path.join(allocator, &[_][]const u8{ dirname, sub_directory.path.? }),	102	.path = try resolvePath(allocator, p),
96	};	103	};
97	}	104	}
98	return error.FileNotFound;	105	return error.FileNotFound;
...	@@ -130,3 +137,46 @@ pub fn resolveGlobalCacheDir(allocator: mem.Allocator) ![]u8 {	...	@@ -130,3 +137,46 @@ pub fn resolveGlobalCacheDir(allocator: mem.Allocator) ![]u8 {
130	return fs.getAppDataDir(allocator, appname);	137	return fs.getAppDataDir(allocator, appname);
131	}	138	}
132	}	139	}
		140
		141	/// Similar to std.fs.path.resolve, with a few important differences:
		142	/// * If the input is an absolute path, check it against the cwd and try to
		143	/// convert it to a relative path.
		144	/// * If the resulting path would start with a relative up-dir ("../"), instead
		145	/// return an absolute path based on the cwd.
		146	/// * When targeting WASI, fail with an error message if an absolute path is
		147	/// used.
		148	pub fn resolvePath(
		149	ally: mem.Allocator,
		150	p: []const u8,
		151	) error{
		152	OutOfMemory,
		153	CurrentWorkingDirectoryUnlinked,
		154	Unexpected,
		155	}![]u8 {
		156	if (fs.path.isAbsolute(p)) {
		157	const cwd_path = try std.process.getCwdAlloc(ally);
		158	defer ally.free(cwd_path);
		159	const relative = try fs.path.relative(ally, cwd_path, p);
		160	if (isUpDir(relative)) {
		161	ally.free(relative);
		162	return ally.dupe(u8, p);
		163	} else {
		164	return relative;
		165	}
		166	} else {
		167	const resolved = try fs.path.resolve(ally, &.{p});
		168	if (isUpDir(resolved)) {
		169	ally.free(resolved);
		170	const cwd_path = try std.process.getCwdAlloc(ally);
		171	defer ally.free(cwd_path);
		172	return fs.path.resolve(ally, &.{ cwd_path, p });
		173	} else {
		174	return resolved;
		175	}
		176	}
		177	}
		178
		179	/// TODO move this to std.fs.path
		180	pub fn isUpDir(p: []const u8) bool {
		181	return mem.startsWith(u8, p, "..") and (p.len == 2 or p[2] == fs.path.sep);
		182	}

src/main.zig+26-17

 @@ -885,24 +885,28 @@ fn buildOutputType(
                             fatal("unexpected end-of-parameter mark: --", .{});
                         }
                     } else if (mem.eql(u8, arg, "--pkg-begin")) {
-                        const pkg_name = args_iter.next();
+                        const opt_pkg_name = args_iter.next();
-                        const pkg_path = args_iter.next();
+                        const opt_pkg_path = args_iter.next();
-                        if (pkg_name == null or pkg_path == null) fatal("Expected 2 arguments after {s}", .{arg});
+                        if (opt_pkg_name == null or opt_pkg_path == null)
+                            fatal("Expected 2 arguments after {s}", .{arg});
+                        const pkg_name = opt_pkg_name.?;
+                        const pkg_path = try introspect.resolvePath(arena, opt_pkg_path.?);
                         const new_cur_pkg = Package.create(
                             gpa,
-                            fs.path.dirname(pkg_path.?),
+                            fs.path.dirname(pkg_path),
-                            fs.path.basename(pkg_path.?),
+                            fs.path.basename(pkg_path),
                         ) catch |err| {
-                            fatal("Failed to add package at path {s}: {s}", .{ pkg_path.?, @errorName(err) });
+                            fatal("Failed to add package at path {s}: {s}", .{ pkg_path, @errorName(err) });
                         };
-                        if (mem.eql(u8, pkg_name.?, "std") or mem.eql(u8, pkg_name.?, "root") or mem.eql(u8, pkg_name.?, "builtin")) {
+                        if (mem.eql(u8, pkg_name, "std") or mem.eql(u8, pkg_name, "root") or mem.eql(u8, pkg_name, "builtin")) {
-                            fatal("unable to add package '{s}' -> '{s}': conflicts with builtin package", .{ pkg_name.?, pkg_path.? });
+                            fatal("unable to add package '{s}' -> '{s}': conflicts with builtin package", .{ pkg_name, pkg_path });
-                        } else if (cur_pkg.table.get(pkg_name.?)) |prev| {
+                        } else if (cur_pkg.table.get(pkg_name)) |prev| {
-                            fatal("unable to add package '{s}' -> '{s}': already exists as '{s}", .{ pkg_name.?, pkg_path.?, prev.root_src_path });
+                            fatal("unable to add package '{s}' -> '{s}': already exists as '{s}", .{ pkg_name, pkg_path, prev.root_src_path });
                         }
-                        try cur_pkg.addAndAdopt(gpa, pkg_name.?, new_cur_pkg);
+                        try cur_pkg.addAndAdopt(gpa, pkg_name, new_cur_pkg);
                         cur_pkg = new_cur_pkg;
                     } else if (mem.eql(u8, arg, "--pkg-end")) {
                         cur_pkg = cur_pkg.parent orelse
 @@ -2705,11 +2709,16 @@ fn buildOutputType(
     };
     defer emit_implib_resolved.deinit();
-    const main_pkg: ?*Package = if (root_src_file) |src_path| blk: {
+    const main_pkg: ?*Package = if (root_src_file) |unresolved_src_path| blk: {
-        if (main_pkg_path) |p| {
+        const src_path = try introspect.resolvePath(arena, unresolved_src_path);
-            const rel_src_path = try fs.path.relative(gpa, p, src_path);
+        if (main_pkg_path) |unresolved_main_pkg_path| {
-            defer gpa.free(rel_src_path);
+            const p = try introspect.resolvePath(arena, unresolved_main_pkg_path);
-            break :blk try Package.create(gpa, p, rel_src_path);
+            if (p.len == 0) {
+                break :blk try Package.create(gpa, null, src_path);
+            } else {
+                const rel_src_path = try fs.path.relative(arena, p, src_path);
+                break :blk try Package.create(gpa, p, rel_src_path);
+            }
         } else {
             const root_src_dir_path = fs.path.dirname(src_path);
             break :blk Package.create(gpa, root_src_dir_path, fs.path.basename(src_path)) catch |err| {
 @@ -2745,7 +2754,7 @@ fn buildOutputType(
     const self_exe_path = try introspect.findZigExePath(arena);
     var zig_lib_directory: Compilation.Directory = if (override_lib_dir) |unresolved_lib_dir| l: {
-        const lib_dir = try fs.path.resolve(arena, &.{unresolved_lib_dir});
+        const lib_dir = try introspect.resolvePath(arena, unresolved_lib_dir);
         break :l .{
             .path = lib_dir,
             .handle = fs.cwd().openDir(lib_dir, .{}) catch |err| {

src/test.zig+1-1

...	@@ -60,7 +60,7 @@ test {	...	@@ -60,7 +60,7 @@ test {
60	ctx.addTestCasesFromDir(dir);	60	ctx.addTestCasesFromDir(dir);
61	}	61	}
62		62
63	try @import("test_cases").addCases(&ctx);	63	try @import("../test/cases.zig").addCases(&ctx);
64		64
65	try ctx.run();	65	try ctx.run();
66	}	66	}