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,16 @@ pub fn dependency(b: *Build, name: []const u8, args: anytype) *Dependency {
         }
     }
 
+    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 +1620,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 +1638,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 +1708,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 +1726,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 +1759,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 +1774,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/Compilation.zig

@@ -700,7 +700,11 @@ fn addPackageTableToCacheHash(
                 const pkg_zig_file = try pkg.value.root_src_directory.join(allocator, &[_][]const u8{
                     pkg.value.root_src_path,
                 });
-                _ = try man.addFile(pkg_zig_file, null);
+                blk: {
+                    pkg.value.root_src_directory.handle.access(pkg.value.root_src_path, .{}) catch break :blk;
+
+                    _ = try man.addFile(pkg_zig_file, null);
+                }
             },
         }
         // Recurse to handle the package's dependencies

src/Package.zig

@@ -330,9 +330,12 @@ pub fn fetchAndAddDependencies(
             try deps_pkg.add(gpa, dep.hash.?, sub.mod);
         }
 
-        try dependencies_source.writer().print("    pub const {s} = @import(\"{}\");\n", .{
-            std.zig.fmtId(fqn), std.zig.fmtEscapes(dep.hash.?),
-        });
+        blk: {
+            sub.mod.root_src_directory.handle.access(build_zig_basename, .{}) catch break :blk;
+            try dependencies_source.writer().print("    pub const {s} = @import(\"{}\");\n", .{
+                std.zig.fmtId(fqn), std.zig.fmtEscapes(dep.hash.?),
+            });
+        }
     }
 }