srctree

Andrew Kelley parent 519ba9bb e3575506
update for the std.fs.Dir changes

inline split

lib/std/Build/Step/InstallDir.zig added: 77, removed: 68, total 9

@@ -69,7 +69,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {

const dest_prefix = dest_builder.getInstallPath(self.options.install_dir, self.options.install_subdir);

const src_builder = self.step.owner;

const src_dir_path = self.options.source_dir.getPath2(src_builder, step);

var src_dir = src_builder.build_root.handle.openIterableDir(src_dir_path, .{}) catch |err| {

var src_dir = src_builder.build_root.handle.openDir(src_dir_path, .{ .iterate = true }) catch |err| {

return step.fail("unable to open source directory '{}{s}': {s}", .{

src_builder.build_root, src_dir_path, @errorName(err),

});

lib/std/child_process.zig added: 77, removed: 68, total 9

@@ -976,7 +976,8 @@ fn windowsCreateProcessPathExt(

defer dir_buf.shrinkRetainingCapacity(dir_path_len);

const dir_path_z = dir_buf.items[0 .. dir_buf.items.len - 1 :0];

const prefixed_path = try windows.wToPrefixedFileW(null, dir_path_z);

break :dir fs.cwd().openDirW(prefixed_path.span().ptr, .{}, true) catch return error.FileNotFound;

break :dir fs.cwd().openDirW(prefixed_path.span().ptr, .{ .iterate = true }) catch

return error.FileNotFound;

};

defer dir.close();

lib/std/crypto/Certificate/Bundle.zig added: 77, removed: 68, total 9

@@ -160,7 +160,7 @@ pub fn addCertsFromDirPath(

dir: fs.Dir,

sub_dir_path: []const u8,

) AddCertsFromDirPathError!void {

var iterable_dir = try dir.openIterableDir(sub_dir_path, .{});

var iterable_dir = try dir.openDir(sub_dir_path, .{ .iterate = true });

defer iterable_dir.close();

return addCertsFromDir(cb, gpa, iterable_dir);

}

@@ -171,14 +171,14 @@ pub fn addCertsFromDirPathAbsolute(

abs_dir_path: []const u8,

) AddCertsFromDirPathError!void {

assert(fs.path.isAbsolute(abs_dir_path));

var iterable_dir = try fs.openIterableDirAbsolute(abs_dir_path, .{});

var iterable_dir = try fs.openDirAbsolute(abs_dir_path, .{ .iterate = true });

defer iterable_dir.close();

return addCertsFromDir(cb, gpa, iterable_dir);

}

pub const AddCertsFromDirError = AddCertsFromFilePathError;

pub fn addCertsFromDir(cb: *Bundle, gpa: Allocator, iterable_dir: fs.IterableDir) AddCertsFromDirError!void {

pub fn addCertsFromDir(cb: *Bundle, gpa: Allocator, iterable_dir: fs.Dir) AddCertsFromDirError!void {

var it = iterable_dir.iterate();

while (try it.next()) |entry| {

switch (entry.kind) {

@@ -186,7 +186,7 @@ pub fn addCertsFromDir(cb: *Bundle, gpa: Allocator, iterable_dir: fs.IterableDir

else => continue,

}

try addCertsFromFilePath(cb, gpa, iterable_dir.dir, entry.name);

try addCertsFromFilePath(cb, gpa, iterable_dir, entry.name);

}

lib/std/fs.zig added: 77, removed: 68, total 9

@@ -1653,12 +1653,12 @@ pub const Dir = struct {

pub fn openDir(self: Dir, sub_path: []const u8, args: OpenDirOptions) OpenError!Dir {

if (builtin.os.tag == .windows) {

const sub_path_w = try os.windows.sliceToPrefixedFileW(self.fd, sub_path);

return .{ .dir = try self.openDirW(sub_path_w.span().ptr, args) };

return self.openDirW(sub_path_w.span().ptr, args);

} else if (builtin.os.tag == .wasi and !builtin.link_libc) {

return .{ .dir = try self.openDirWasi(sub_path, args) };

return self.openDirWasi(sub_path, args);

} else {

const sub_path_c = try os.toPosixPath(sub_path);

return .{ .dir = try self.openDirZ(&sub_path_c, args) };

return self.openDirZ(&sub_path_c, args);

}

@@ -2784,12 +2784,12 @@ pub fn openDirAbsolute(absolute_path: []const u8, flags: Dir.OpenDirOptions) Fil

/// Same as `openDirAbsolute` but the path parameter is null-terminated.

pub fn openDirAbsoluteZ(absolute_path_c: [*:0]const u8, flags: Dir.OpenDirOptions) File.OpenError!Dir {

assert(path.isAbsoluteZ(absolute_path_c));

return cwd().openDirZ(absolute_path_c, flags, false);

return cwd().openDirZ(absolute_path_c, flags);

}

/// Same as `openDirAbsolute` but the path parameter is null-terminated.

pub fn openDirAbsoluteW(absolute_path_c: [*:0]const u16, flags: Dir.OpenDirOptions) File.OpenError!Dir {

assert(path.isAbsoluteWindowsW(absolute_path_c));

return cwd().openDirW(absolute_path_c, flags, false);

return cwd().openDirW(absolute_path_c, flags);

}

/// Opens a file for reading or writing, without attempting to create a new file, based on an absolute path.

lib/std/fs/test.zig added: 77, removed: 68, total 9

@@ -72,9 +72,8 @@ const PathType = enum {

const TestContext = struct {

path_type: PathType,

arena: ArenaAllocator,

tmp: testing.TmpIterableDir,

tmp: testing.TmpDir,

dir: std.fs.Dir,

iterable_dir: std.fs.Dir,

transform_fn: *const PathType.TransformFn,

pub fn init(path_type: PathType, allocator: mem.Allocator, transform_fn: *const PathType.TransformFn) TestContext {

@@ -83,8 +82,7 @@ const TestContext = struct {

.path_type = path_type,

.arena = ArenaAllocator.init(allocator),

.tmp = tmp,

.dir = tmp.iterable_dir.dir,

.iterable_dir = tmp.iterable_dir,

.dir = tmp.dir,

.transform_fn = transform_fn,

};

}

@@ -359,7 +357,7 @@ test "Dir.Iterator many entries" {

var buf: [4]u8 = undefined; // Enough to store "1024".

while (i < num) : (i += 1) {

const name = try std.fmt.bufPrint(&buf, "{}", .{i});

const file = try tmp_dir.iterable_dir.dir.createFile(name, .{});

const file = try tmp_dir.dir.createFile(name, .{});

file.close();

}

@@ -370,7 +368,7 @@ test "Dir.Iterator many entries" {

var entries = std.ArrayList(Dir.Entry).init(allocator);

// Create iterator.

var iter = tmp_dir.iterable_dir.iterate();

var iter = tmp_dir.dir.iterate();

while (try iter.next()) |entry| {

// We cannot just store `entry` as on Windows, we're re-using the name buffer

// which means we'll actually share the `name` pointer between entries!

@@ -423,17 +421,17 @@ test "Dir.Iterator reset" {

defer tmp_dir.cleanup();

// First, create a couple of entries to iterate over.

const file = try tmp_dir.iterable_dir.dir.createFile("some_file", .{});

const file = try tmp_dir.dir.createFile("some_file", .{});

file.close();

try tmp_dir.iterable_dir.dir.makeDir("some_dir");

try tmp_dir.dir.makeDir("some_dir");

var arena = ArenaAllocator.init(testing.allocator);

defer arena.deinit();

const allocator = arena.allocator();

// Create iterator.

var iter = tmp_dir.iterable_dir.iterate();

var iter = tmp_dir.dir.iterate();

var i: u8 = 0;

while (i < 2) : (i += 1) {

@@ -459,10 +457,10 @@ test "Dir.Iterator but dir is deleted during iteration" {

defer tmp.cleanup();

// Create directory and setup an iterator for it

var iterable_subdir = try tmp.dir.makeOpenPathIterable("subdir", .{});

defer iterable_subdir.close();

var subdir = try tmp.dir.makeOpenPath("subdir", .{ .iterate = true });

defer subdir.close();

var iterator = iterable_subdir.iterate();

var iterator = subdir.iterate();

// Create something to iterate over within the subdir

try tmp.dir.makePath("subdir/b");

@@ -964,7 +962,7 @@ test "makePath in a directory that no longer exists" {

fn testFilenameLimits(iterable_dir: Dir, maxed_filename: []const u8) !void {

// setup, create a dir and a nested file both with maxed filenames, and walk the dir

{

var maxed_dir = try iterable_dir.dir.makeOpenPath(maxed_filename, .{});

var maxed_dir = try iterable_dir.makeOpenPath(maxed_filename, .{});

defer maxed_dir.close();

try maxed_dir.writeFile(maxed_filename, "");

@@ -981,7 +979,7 @@ fn testFilenameLimits(iterable_dir: Dir, maxed_filename: []const u8) !void {

}

// ensure that we can delete the tree

try iterable_dir.dir.deleteTree(maxed_filename);

try iterable_dir.deleteTree(maxed_filename);

}

test "max file name component lengths" {

@@ -992,16 +990,16 @@ test "max file name component lengths" {

// U+FFFF is the character with the largest code point that is encoded as a single

// UTF-16 code unit, so Windows allows for NAME_MAX of them.

const maxed_windows_filename = ("\u{FFFF}".*) ** std.os.windows.NAME_MAX;

try testFilenameLimits(tmp.iterable_dir, &maxed_windows_filename);

try testFilenameLimits(tmp.dir, &maxed_windows_filename);

} else if (builtin.os.tag == .wasi) {

// On WASI, the maxed filename depends on the host OS, so in order for this test to

// work on any host, we need to use a length that will work for all platforms

// (i.e. the minimum MAX_NAME_BYTES of all supported platforms).

const maxed_wasi_filename = [_]u8{'1'} ** 255;

try testFilenameLimits(tmp.iterable_dir, &maxed_wasi_filename);

try testFilenameLimits(tmp.dir, &maxed_wasi_filename);

} else {

const maxed_ascii_filename = [_]u8{'1'} ** std.fs.MAX_NAME_BYTES;

try testFilenameLimits(tmp.iterable_dir, &maxed_ascii_filename);

try testFilenameLimits(tmp.dir, &maxed_ascii_filename);

}

@@ -1438,14 +1436,14 @@ test "walker without fully iterating" {

var tmp = tmpDir(.{ .iterate = true });

defer tmp.cleanup();

var walker = try tmp.iterable_dir.walk(testing.allocator);

var walker = try tmp.dir.walk(testing.allocator);

defer walker.deinit();

// Create 2 directories inside the tmp directory, but then only iterate once before breaking.

// This ensures that walker doesn't try to close the initial directory when not fully iterating.

try tmp.iterable_dir.dir.makePath("a");

try tmp.iterable_dir.dir.makePath("b");

try tmp.dir.makePath("a");

try tmp.dir.makePath("b");

var num_walked: usize = 0;

while (try walker.next()) |_| {

src/Package/Fetch.zig added: 77, removed: 68, total 9

@@ -280,7 +280,7 @@ pub fn run(f: *Fetch) RunError!void {

.remote => |remote| remote,

.path_or_url => |path_or_url| {

if (fs.cwd().openIterableDir(path_or_url, .{})) |dir| {

if (fs.cwd().openDir(path_or_url, .{ .iterate = true })) |dir| {

var resource: Resource = .{ .dir = dir };

return runResource(f, path_or_url, &resource, null);

} else |dir_err| {

@@ -363,7 +363,9 @@ fn runResource(

var tmp_directory: Cache.Directory = .{

.path = tmp_directory_path,

.handle = handle: {

const dir = cache_root.handle.makeOpenPathIterable(tmp_dir_sub_path, .{}) catch |err| {

const dir = cache_root.handle.makeOpenPath(tmp_dir_sub_path, .{

.iterate = true,

}) catch |err| {

try eb.addRootErrorMessage(.{

.msg = try eb.printString("unable to create temporary directory '{s}': {s}", .{

tmp_directory_path, @errorName(err),

@@ -371,7 +373,7 @@ fn runResource(

});

return error.FetchFailed;

};

break :handle dir.dir;

break :handle dir;

};

defer tmp_directory.handle.close();

@@ -400,9 +402,9 @@ fn runResource(

if (builtin.os.tag == .linux and f.job_queue.work_around_btrfs_bug) {

// https://github.com/ziglang/zig/issues/17095

tmp_directory.handle.close();

const iterable_dir = cache_root.handle.makeOpenPathIterable(tmp_dir_sub_path, .{}) catch

@panic("btrfs workaround failed");

tmp_directory.handle = iterable_dir.dir;

tmp_directory.handle = cache_root.handle.makeOpenPath(tmp_dir_sub_path, .{

.iterate = true,

}) catch @panic("btrfs workaround failed");

}

f.actual_hash = try computeHash(f, tmp_directory, filter);

@@ -717,7 +719,7 @@ const Resource = union(enum) {

file: fs.File,

http_request: std.http.Client.Request,

git: Git,

dir: fs.IterableDir,

dir: fs.Dir,

const Git = struct {

fetch_stream: git.Session.FetchStream,

@@ -1198,7 +1200,7 @@ fn unpackGitPack(f: *Fetch, out_dir: fs.Dir, resource: *Resource) anyerror!void

try out_dir.deleteTree(".git");

}

fn recursiveDirectoryCopy(f: *Fetch, dir: fs.IterableDir, tmp_dir: fs.Dir) anyerror!void {

fn recursiveDirectoryCopy(f: *Fetch, dir: fs.Dir, tmp_dir: fs.Dir) anyerror!void {

const gpa = f.arena.child_allocator;

// Recursive directory copy.

var it = try dir.walk(gpa);

@@ -1207,7 +1209,7 @@ fn recursiveDirectoryCopy(f: *Fetch, dir: fs.IterableDir, tmp_dir: fs.Dir) anyer

switch (entry.kind) {

.directory => {}, // omit empty directories

.file => {

dir.dir.copyFile(

dir.copyFile(

entry.path,

tmp_dir,

entry.path,

@@ -1215,14 +1217,14 @@ fn recursiveDirectoryCopy(f: *Fetch, dir: fs.IterableDir, tmp_dir: fs.Dir) anyer

) catch |err| switch (err) {

error.FileNotFound => {

if (fs.path.dirname(entry.path)) |dirname| try tmp_dir.makePath(dirname);

try dir.dir.copyFile(entry.path, tmp_dir, entry.path, .{});

try dir.copyFile(entry.path, tmp_dir, entry.path, .{});

else => |e| return e,

};

.sym_link => {

var buf: [fs.MAX_PATH_BYTES]u8 = undefined;

const link_name = try dir.dir.readLink(entry.path, &buf);

const link_name = try dir.readLink(entry.path, &buf);

// TODO: if this would create a symlink to outside

// the destination directory, fail with an error instead.

tmp_dir.symLink(link_name, entry.path, .{}) catch |err| switch (err) {

@@ -1296,7 +1298,7 @@ fn computeHash(

var sus_dirs: std.StringArrayHashMapUnmanaged(void) = .{};

defer sus_dirs.deinit(gpa);

var walker = try @as(fs.IterableDir, .{ .dir = tmp_directory.handle }).walk(gpa);

var walker = try tmp_directory.handle.walk(gpa);

defer walker.deinit();

{

src/Package/Fetch/git.zig added: 77, removed: 68, total 9

@@ -1384,11 +1384,11 @@ test "packfile indexing and checkout" {

var repository = try Repository.init(testing.allocator, pack_file, index_file);

defer repository.deinit();

var worktree = testing.tmpIterableDir(.{});

var worktree = testing.tmpDir(.{ .iterate = true });

defer worktree.cleanup();

const commit_id = try parseOid("dd582c0720819ab7130b103635bd7271b9fd4feb");

try repository.checkout(worktree.iterable_dir.dir, commit_id);

try repository.checkout(worktree.dir, commit_id);

const expected_files: []const []const u8 = &.{

"dir/file",

@@ -1410,7 +1410,7 @@ test "packfile indexing and checkout" {

var actual_files: std.ArrayListUnmanaged([]u8) = .{};

defer actual_files.deinit(testing.allocator);

defer for (actual_files.items) |file| testing.allocator.free(file);

var walker = try worktree.iterable_dir.walk(testing.allocator);

var walker = try worktree.dir.walk(testing.allocator);

defer walker.deinit();

while (try walker.next()) |entry| {

if (entry.kind != .file) continue;

@@ -1442,7 +1442,7 @@ test "packfile indexing and checkout" {

\\revision 19

;

const actual_file_contents = try worktree.iterable_dir.dir.readFileAlloc(testing.allocator, "file", max_file_size);

const actual_file_contents = try worktree.dir.readFileAlloc(testing.allocator, "file", max_file_size);

defer testing.allocator.free(actual_file_contents);

try testing.expectEqualStrings(expected_file_contents, actual_file_contents);

}

src/windows_sdk.zig added: 77, removed: 68, total 9

@@ -14,7 +14,11 @@ const product_version_max_length = version_major_minor_max_length + ".65535".len

/// Iterates via `iterator` and collects all folders with names starting with `optional_prefix`

/// and similar to SemVer. Returns slice of folder names sorted in descending order.

/// Caller owns result.

fn iterateAndFilterBySemVer(iterator: *std.fs.IterableDir.Iterator, allocator: std.mem.Allocator, comptime optional_prefix: ?[]const u8) error{ OutOfMemory, VersionNotFound }![][]const u8 {

fn iterateAndFilterBySemVer(

iterator: *std.fs.Dir.Iterator,

allocator: std.mem.Allocator,

comptime optional_prefix: ?[]const u8,

) error{ OutOfMemory, VersionNotFound }![][]const u8 {

var dirs_filtered_list = std.ArrayList([]const u8).init(allocator);

errdefer {

for (dirs_filtered_list.items) |filtered_dir| allocator.free(filtered_dir);

@@ -476,7 +480,9 @@ pub const Windows81Sdk = struct {

if (!std.fs.path.isAbsolute(sdk_lib_dir_path)) return error.Windows81SdkNotFound;

// enumerate files in sdk path looking for latest version

var sdk_lib_dir = std.fs.openIterableDirAbsolute(sdk_lib_dir_path, .{}) catch |err| switch (err) {

var sdk_lib_dir = std.fs.openDirAbsolute(sdk_lib_dir_path, .{

.iterate = true,

}) catch |err| switch (err) {

error.NameTooLong => return error.PathTooLong,

else => return error.Windows81SdkNotFound,

};

@@ -727,7 +733,9 @@ const MsvcLibDir = struct {

if (!std.fs.path.isAbsolute(visualstudio_folder_path)) return error.PathNotFound;

// enumerate folders that contain `privateregistry.bin`, looking for all versions

// f.i. %localappdata%\Microsoft\VisualStudio\17.0_9e9cbb98\

var visualstudio_folder = std.fs.openIterableDirAbsolute(visualstudio_folder_path, .{}) catch return error.PathNotFound;

var visualstudio_folder = std.fs.openDirAbsolute(visualstudio_folder_path, .{

.iterate = true,

}) catch return error.PathNotFound;

defer visualstudio_folder.close();

var iterator = visualstudio_folder.iterate();

test/src/Cases.zig added: 77, removed: 68, total 9

@@ -368,7 +368,7 @@ pub fn addCompile(

/// Each file should include a test manifest as a contiguous block of comments at

/// the end of the file. The first line should be the test type, followed by a set of

/// key-value config values, followed by a blank line, then the expected output.

pub fn addFromDir(ctx: *Cases, dir: std.fs.IterableDir) void {

pub fn addFromDir(ctx: *Cases, dir: std.fs.Dir) void {

var current_file: []const u8 = "none";

ctx.addFromDirInner(dir, &current_file) catch |err| {

std.debug.panicExtra(

@@ -382,7 +382,7 @@ pub fn addFromDir(ctx: *Cases, dir: std.fs.IterableDir) void {

fn addFromDirInner(

ctx: *Cases,

iterable_dir: std.fs.IterableDir,

iterable_dir: std.fs.Dir,

/// This is kept up to date with the currently being processed file so

/// that if any errors occur the caller knows it happened during this file.

current_file: *[]const u8,

@@ -416,7 +416,7 @@ fn addFromDirInner(

}

const max_file_size = 10 * 1024 * 1024;

const src = try iterable_dir.dir.readFileAllocOptions(ctx.arena, filename, max_file_size, null, 1, 0);

const src = try iterable_dir.readFileAllocOptions(ctx.arena, filename, max_file_size, null, 1, 0);

// Parse the manifest

var manifest = try TestManifest.parse(ctx.arena, src);

@@ -1246,7 +1246,7 @@ pub fn main() !void {

var filenames = std.ArrayList([]const u8).init(arena);

const case_dirname = std.fs.path.dirname(case_file_path).?;

var iterable_dir = try std.fs.cwd().openIterableDir(case_dirname, .{});

var iterable_dir = try std.fs.cwd().openDir(case_dirname, .{ .iterate = true });

defer iterable_dir.close();

if (std.mem.endsWith(u8, case_file_path, ".0.zig")) {

@@ -1280,7 +1280,7 @@ pub fn main() !void {

for (batch) |filename| {

const max_file_size = 10 * 1024 * 1024;

const src = try iterable_dir.dir.readFileAllocOptions(arena, filename, max_file_size, null, 1, 0);

const src = try iterable_dir.readFileAllocOptions(arena, filename, max_file_size, null, 1, 0);

// Parse the manifest

var manifest = try TestManifest.parse(arena, src);

test/tests.zig added: 77, removed: 68, total 9

@@ -1288,7 +1288,7 @@ pub fn addCases(

var cases = @import("src/Cases.zig").init(gpa, arena);

var dir = try b.build_root.handle.openIterableDir("test/cases", .{});

var dir = try b.build_root.handle.openDir("test/cases", .{ .iterate = true });

defer dir.close();

cases.addFromDir(dir);

tools/generate_JSONTestSuite.zig added: 77, removed: 68, total 9

@@ -18,7 +18,7 @@ pub fn main() !void {

);

var names = std.ArrayList([]const u8).init(allocator);

var cwd = try std.fs.cwd().openIterableDir(".", .{});

var cwd = try std.fs.cwd().openDir(".", .{ .iterate = true });

var it = cwd.iterate();

while (try it.next()) |entry| {

try names.append(try allocator.dupe(u8, entry.name));