Manifest: add top-level paths field for inclusion rules

See #14311

Author: andrewrk

src/Manifest.zig

@@ -1,3 +1,4 @@
+pub const max_bytes = 10 * 1024 * 1024;
 pub const basename = "build.zig.zon";
 pub const Hash = std.crypto.hash.sha2.Sha256;
 
@@ -50,6 +51,7 @@ pub const multihash_len = 1 + 1 + Hash.digest_length;
 name: []const u8,
 version: std.SemanticVersion,
 dependencies: std.StringArrayHashMapUnmanaged(Dependency),
+paths: std.StringArrayHashMapUnmanaged(void),
 
 errors: []ErrorMessage,
 arena_state: std.heap.ArenaAllocator.State,
@@ -74,11 +76,13 @@ pub fn parse(gpa: Allocator, ast: std.zig.Ast) Error!Manifest {
         .name = undefined,
         .version = undefined,
         .dependencies = .{},
+        .paths = .{},
         .buf = .{},
     };
     defer p.buf.deinit(gpa);
     defer p.errors.deinit(gpa);
     defer p.dependencies.deinit(gpa);
+    defer p.paths.deinit(gpa);
 
     p.parseRoot(main_node_index) catch |err| switch (err) {
         error.ParseFailure => assert(p.errors.items.len > 0),
@@ -89,6 +93,7 @@ pub fn parse(gpa: Allocator, ast: std.zig.Ast) Error!Manifest {
         .name = p.name,
         .version = p.version,
         .dependencies = try p.dependencies.clone(p.arena),
+        .paths = try p.paths.clone(p.arena),
         .errors = try p.arena.dupe(ErrorMessage, p.errors.items),
         .arena_state = arena_instance.state,
     };
@@ -143,6 +148,7 @@ const Parse = struct {
     name: []const u8,
     version: std.SemanticVersion,
     dependencies: std.StringArrayHashMapUnmanaged(Dependency),
+    paths: std.StringArrayHashMapUnmanaged(void),
 
     const InnerError = error{ ParseFailure, OutOfMemory };
 
@@ -158,6 +164,7 @@ const Parse = struct {
 
         var have_name = false;
         var have_version = false;
+        var have_included_paths = false;
 
         for (struct_init.ast.fields) |field_init| {
             const name_token = ast.firstToken(field_init) - 2;
@@ -167,6 +174,8 @@ const Parse = struct {
             // that is desirable on a per-field basis.
             if (mem.eql(u8, field_name, "dependencies")) {
                 try parseDependencies(p, field_init);
+            } else if (mem.eql(u8, field_name, "paths")) {
+                try parseIncludedPaths(p, field_init);
             } else if (mem.eql(u8, field_name, "name")) {
                 p.name = try parseString(p, field_init);
                 have_name = true;
@@ -190,6 +199,10 @@ const Parse = struct {
         if (!have_version) {
             try appendError(p, main_token, "missing top-level 'version' field", .{});
         }
+
+        if (!have_included_paths) {
+            try appendError(p, main_token, "missing top-level 'paths' field", .{});
+        }
     }
 
     fn parseDependencies(p: *Parse, node: Ast.Node.Index) !void {
@@ -277,6 +290,23 @@ const Parse = struct {
         return dep;
     }
 
+    fn parseIncludedPaths(p: *Parse, node: Ast.Node.Index) !void {
+        const ast = p.ast;
+        const main_tokens = ast.nodes.items(.main_token);
+
+        var buf: [2]Ast.Node.Index = undefined;
+        const array_init = ast.fullArrayInit(&buf, node) orelse {
+            const tok = main_tokens[node];
+            return fail(p, tok, "expected paths expression to be a struct", .{});
+        };
+
+        for (array_init.ast.elements) |elem_node| {
+            const path_string = try parseString(p, elem_node);
+            const normalized = try std.fs.path.resolve(p.arena, &.{path_string});
+            try p.paths.put(p.gpa, normalized, {});
+        }
+    }
+
     fn parseString(p: *Parse, node: Ast.Node.Index) ![]const u8 {
         const ast = p.ast;
         const node_tags = ast.nodes.items(.tag);