Support non zig dependencies

Dependencies no longer require a build.zig file.

Adds path function to Dependency struct which
returns a LazyPath into a dependency.

Author: antlilja

lib/std/Build.zig

@@ -1556,6 +1556,15 @@ pub const Dependency = struct {
             panic("unable to find module '{s}'", .{name});
         };
     }
+
+    pub fn path(d: *Dependency, sub_path: []const u8) LazyPath {
+        return .{
+            .dependency = .{
+                .dependency = d,
+                .sub_path = sub_path,
+            },
+        };
+    }
 };
 
 pub fn dependency(b: *Build, name: []const u8, args: anytype) *Dependency {
@@ -1573,6 +1582,18 @@ pub fn dependency(b: *Build, name: []const u8, args: anytype) *Dependency {
         }
     }
 
+    // If the name wasn't found among the imports this dependency might not have a build.zig file,
+    // we therefore look through the build roots aswell.
+    inline for (@typeInfo(deps.build_root).Struct.decls) |decl| {
+        if (mem.startsWith(u8, decl.name, b.dep_prefix) and
+            mem.endsWith(u8, decl.name, name) and
+            decl.name.len == b.dep_prefix.len + name.len)
+        {
+            const build_root = @field(deps.build_root, decl.name);
+            return dependencyInner(b, name, build_root, null, args);
+        }
+    }
+
     const full_path = b.pathFromRoot("build.zig.zon");
     std.debug.print("no dependency named '{s}' in '{s}'. All packages used in build.zig must be declared in this file.\n", .{ name, full_path });
     process.exit(1);
@@ -1601,7 +1622,7 @@ pub fn dependencyInner(
     b: *Build,
     name: []const u8,
     build_root_string: []const u8,
-    comptime build_zig: type,
+    comptime maybe_build_zig: ?type,
     args: anytype,
 ) *Dependency {
     if (b.initialized_deps.get(build_root_string)) |dep| {
@@ -1619,10 +1640,12 @@ pub fn dependencyInner(
         },
     };
     const sub_builder = b.createChild(name, build_root, args) catch @panic("unhandled error");
-    sub_builder.runBuild(build_zig) catch @panic("unhandled error");
+    if (maybe_build_zig) |build_zig| {
+        sub_builder.runBuild(build_zig) catch @panic("unhandled error");
 
-    if (sub_builder.validateUserInputDidItFail()) {
-        std.debug.dumpCurrentStackTrace(@returnAddress());
+        if (sub_builder.validateUserInputDidItFail()) {
+            std.debug.dumpCurrentStackTrace(@returnAddress());
+        }
     }
 
     const dep = b.allocator.create(Dependency) catch @panic("OOM");
@@ -1687,6 +1710,11 @@ pub const LazyPath = union(enum) {
     /// Use of this tag indicates a dependency on the host system.
     cwd_relative: []const u8,
 
+    dependency: struct {
+        dependency: *Dependency,
+        sub_path: []const u8,
+    },
+
     /// Returns a new file source that will have a relative path to the build root guaranteed.
     /// Asserts the parameter is not an absolute path.
     pub fn relative(path: []const u8) LazyPath {
@@ -1700,13 +1728,14 @@ pub const LazyPath = union(enum) {
         return switch (self) {
             .path, .cwd_relative => self.path,
             .generated => "generated",
+            .dependency => "dependency",
         };
     }
 
     /// Adds dependencies this file source implies to the given step.
     pub fn addStepDependencies(self: LazyPath, other_step: *Step) void {
         switch (self) {
-            .path, .cwd_relative => {},
+            .path, .cwd_relative, .dependency => {},
             .generated => |gen| other_step.dependOn(gen.step),
         }
     }
@@ -1732,6 +1761,12 @@ pub const LazyPath = union(enum) {
                 dumpBadGetPathHelp(gen.step, stderr, src_builder, asking_step) catch {};
                 @panic("misconfigured build script");
             },
+            .dependency => |dep| {
+                return dep.dependency.builder.pathJoin(&[_][]const u8{
+                    dep.dependency.builder.build_root.path.?,
+                    dep.sub_path,
+                });
+            },
         }
     }
 
@@ -1741,6 +1776,7 @@ pub const LazyPath = union(enum) {
             .path => |p| .{ .path = b.dupePath(p) },
             .cwd_relative => |p| .{ .cwd_relative = b.dupePath(p) },
             .generated => |gen| .{ .generated = gen },
+            .dependency => |dep| .{ .dependency = dep },
         };
     }
 };

lib/std/Build/Step/Compile.zig

@@ -1841,7 +1841,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                     continue;
                 }
             },
-            .generated => {},
+            .generated, .dependency => {},
         };
 
         zig_args.appendAssumeCapacity(rpath.getPath2(b, step));

src/Package.zig

@@ -303,36 +303,38 @@ pub fn fetchAndAddDependencies(
             root_prog_node,
         );
 
-        if (!sub.found_existing) {
-            try sub.mod.fetchAndAddDependencies(
-                deps_pkg,
-                arena,
-                thread_pool,
-                http_client,
-                sub.mod.root_src_directory,
-                global_cache_directory,
-                local_cache_directory,
-                dependencies_source,
-                build_roots_source,
-                sub_prefix,
-                error_bundle,
-                all_modules,
-                root_prog_node,
-            );
-        }
+        if (sub.mod) |mod| {
+            if (!sub.found_existing) {
+                try mod.fetchAndAddDependencies(
+                    deps_pkg,
+                    arena,
+                    thread_pool,
+                    http_client,
+                    mod.root_src_directory,
+                    global_cache_directory,
+                    local_cache_directory,
+                    dependencies_source,
+                    build_roots_source,
+                    sub_prefix,
+                    error_bundle,
+                    all_modules,
+                    root_prog_node,
+                );
+            }
 
-        try pkg.add(gpa, name, sub.mod);
-        if (deps_pkg.table.get(dep.hash.?)) |other_sub| {
-            // This should be the same package (and hence module) since it's the same hash
-            // TODO: dedup multiple versions of the same package
-            assert(other_sub == sub.mod);
-        } else {
-            try deps_pkg.add(gpa, dep.hash.?, sub.mod);
-        }
+            try pkg.add(gpa, name, mod);
+            if (deps_pkg.table.get(dep.hash.?)) |other_sub| {
+                // This should be the same package (and hence module) since it's the same hash
+                // TODO: dedup multiple versions of the same package
+                assert(other_sub == mod);
+            } else {
+                try deps_pkg.add(gpa, dep.hash.?, mod);
+            }
 
-        try dependencies_source.writer().print("    pub const {s} = @import(\"{}\");\n", .{
-            std.zig.fmtId(fqn), std.zig.fmtEscapes(dep.hash.?),
-        });
+            try dependencies_source.writer().print("    pub const {s} = @import(\"{}\");\n", .{
+                std.zig.fmtId(fqn), std.zig.fmtEscapes(dep.hash.?),
+            });
+        }
     }
 }
 
@@ -420,7 +422,10 @@ const MultiHashHexDigest = [hex_multihash_len]u8;
 /// This is to avoid creating multiple modules for the same build.zig file.
 /// If the value is `null`, the package is a known dependency, but has not yet
 /// been fetched.
-pub const AllModules = std.AutoHashMapUnmanaged(MultiHashHexDigest, ?*Package);
+pub const AllModules = std.AutoHashMapUnmanaged(MultiHashHexDigest, ?union(enum) {
+    zig_pkg: *Package,
+    non_zig_pkg: void,
+});
 
 fn ProgressReader(comptime ReaderType: type) type {
     return struct {
@@ -474,7 +479,7 @@ fn fetchAndUnpack(
     fqn: []const u8,
     all_modules: *AllModules,
     root_prog_node: *std.Progress.Node,
-) !struct { mod: *Package, found_existing: bool } {
+) !struct { mod: ?*Package, found_existing: bool } {
     const gpa = http_client.allocator;
     const s = fs.path.sep_str;
 
@@ -503,15 +508,26 @@ fn fetchAndUnpack(
         if (gop.found_existing) {
             if (gop.value_ptr.*) |mod| {
                 gpa.free(build_root);
-                return .{
-                    .mod = mod,
-                    .found_existing = true,
-                };
+                switch (mod) {
+                    .zig_pkg => |pkg| return .{
+                        .mod = pkg,
+                        .found_existing = true,
+                    },
+                    .non_zig_pkg => return .{
+                        .mod = null,
+                        .found_existing = true,
+                    },
+                }
             }
         }
 
         root_prog_node.completeOne();
 
+        pkg_dir.access(build_zig_basename, .{}) catch return .{
+            .mod = null,
+            .found_existing = false,
+        };
+
         const ptr = try gpa.create(Package);
         errdefer gpa.destroy(ptr);
 
@@ -527,7 +543,7 @@ fn fetchAndUnpack(
             .root_src_path = owned_src_path,
         };
 
-        gop.value_ptr.* = ptr;
+        gop.value_ptr.* = .{ .zig_pkg = ptr };
         return .{
             .mod = ptr,
             .found_existing = false,
@@ -673,8 +689,20 @@ fn fetchAndUnpack(
         std.zig.fmtId(fqn), std.zig.fmtEscapes(build_root),
     });
 
+    {
+        var build_root_dir = try std.fs.openDirAbsolute(build_root, .{});
+        defer build_root_dir.close();
+        build_root_dir.access(build_zig_basename, .{}) catch {
+            try all_modules.put(gpa, actual_hex, .non_zig_pkg);
+            return .{
+                .mod = null,
+                .found_existing = false,
+            };
+        };
+    }
+
     const mod = try createWithDir(gpa, global_cache_directory, pkg_dir_sub_path, build_zig_basename);
-    try all_modules.put(gpa, actual_hex, mod);
+    try all_modules.put(gpa, actual_hex, .{ .zig_pkg = mod });
     return .{
         .mod = mod,
         .found_existing = false,