Commit e204a6edb8866093a087ef2325a5d6ea1824487c | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-04-07 15:43:54-07:00
committer	GitHub <noreply@github.com> 2024-04-07 15:43:54-07:00
log	e204a6edb8866093a087ef2325a5d6ea1824487c
tree	8d4b1db9110c55bb0684791d7f2b33a8a19eb247
parent	278db0ad4543d7a768c63c5482b8873b58690920
parent	b381fb805cfe382a6786f2f1ae670d440d4184bf
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #18988 from castholm/lazy-build-zig

std.Build: add `lazyImport` (`@import` for lazy dependencies)

5 files changed, 86 insertions(+), 10 deletions(-)

lib
- compiler
  - build_runner.zig
- std
  - Build.zig
  - math
    nextafter.zig
src
- Sema.zig
test
- behavior
  - fn.zig

lib/compiler/build_runner.zig+1-1

...	@@ -1,4 +1,3 @@	...	@@ -1,4 +1,3 @@
1	const root = @import("@build");
2	const std = @import("std");	1	const std = @import("std");
3	const builtin = @import("builtin");	2	const builtin = @import("builtin");
4	const assert = std.debug.assert;	3	const assert = std.debug.assert;
...	@@ -10,6 +9,7 @@ const ArrayList = std.ArrayList;	...	@@ -10,6 +9,7 @@ const ArrayList = std.ArrayList;
10	const File = std.fs.File;	9	const File = std.fs.File;
11	const Step = std.Build.Step;	10	const Step = std.Build.Step;
12		11
		12	pub const root = @import("@build");
13	pub const dependencies = @import("@dependencies");	13	pub const dependencies = @import("@dependencies");
14		14
15	pub fn main() !void {	15	pub fn main() !void {

lib/std/Build.zig+67-5

 @@ -93,6 +93,8 @@ named_writefiles: std.StringArrayHashMap(*Step.WriteFile),
 /// A map from build root dirs to the corresponding `*Dependency`. This is shared with all child
 /// `Build`s.
 initialized_deps: *InitializedDepMap,
+/// The hash of this instance's package. `""` means that this is the root package.
+pkg_hash: []const u8,
 /// A mapping from dependency names to package hashes.
 available_deps: AvailableDeps,
 @@ -305,6 +307,7 @@ pub fn create(
         .modules = std.StringArrayHashMap(*Module).init(arena),
         .named_writefiles = std.StringArrayHashMap(*Step.WriteFile).init(arena),
         .initialized_deps = initialized_deps,
+        .pkg_hash = "",
         .available_deps = available_deps,
         .release_mode = .off,
     };
 @@ -318,10 +321,11 @@ fn createChild(
     parent: *Build,
     dep_name: []const u8,
     build_root: Cache.Directory,
+    pkg_hash: []const u8,
     pkg_deps: AvailableDeps,
     user_input_options: UserInputOptionsMap,
 ) !*Build {
-    const child = try createChildOnly(parent, dep_name, build_root, pkg_deps, user_input_options);
+    const child = try createChildOnly(parent, dep_name, build_root, pkg_hash, pkg_deps, user_input_options);
     try determineAndApplyInstallPrefix(child);
     return child;
 }
 @@ -330,6 +334,7 @@ fn createChildOnly(
     parent: *Build,
     dep_name: []const u8,
     build_root: Cache.Directory,
+    pkg_hash: []const u8,
     pkg_deps: AvailableDeps,
     user_input_options: UserInputOptionsMap,
 ) !*Build {
 @@ -397,6 +402,7 @@ fn createChildOnly(
         .modules = std.StringArrayHashMap(*Module).init(allocator),
         .named_writefiles = std.StringArrayHashMap(*Step.WriteFile).init(allocator),
         .initialized_deps = parent.initialized_deps,
+        .pkg_hash = pkg_hash,
         .available_deps = pkg_deps,
         .release_mode = parent.release_mode,
     };
 @@ -1831,6 +1837,26 @@ fn findPkgHashOrFatal(b: *Build, name: []const u8) []const u8 {
     std.debug.panic("no dependency named '{s}' in '{s}'. All packages used in build.zig must be declared in this file", .{ name, full_path });
 }
+inline fn findImportPkgHashOrFatal(b: *Build, comptime asking_build_zig: type, comptime dep_name: []const u8) []const u8 {
+    const build_runner = @import("root");
+    const deps = build_runner.dependencies;
+    const b_pkg_hash, const b_pkg_deps = comptime for (@typeInfo(deps.packages).Struct.decls) |decl| {
+        const pkg_hash = decl.name;
+        const pkg = @field(deps.packages, pkg_hash);
+        if (@hasDecl(pkg, "build_zig") and pkg.build_zig == asking_build_zig) break .{ pkg_hash, pkg.deps };
+    } else .{ "", deps.root_deps };
+    if (!std.mem.eql(u8, b_pkg_hash, b.pkg_hash)) {
+        std.debug.panic("'{}' is not the struct that corresponds to '{s}'", .{ asking_build_zig, b.pathFromRoot("build.zig") });
+    }
+    comptime for (b_pkg_deps) |dep| {
+        if (std.mem.eql(u8, dep[0], dep_name)) return dep[1];
+    };
+    const full_path = b.pathFromRoot("build.zig.zon");
+    std.debug.panic("no dependency named '{s}' in '{s}'. All packages used in build.zig must be declared in this file", .{ dep_name, full_path });
+}
 fn markNeededLazyDep(b: *Build, pkg_hash: []const u8) void {
     b.graph.needed_lazy_dependencies.put(b.graph.arena, pkg_hash, {}) catch @panic("OOM");
 }
 @@ -1861,7 +1887,7 @@ pub fn lazyDependency(b: *Build, name: []const u8, args: anytype) ?*Dependency {
                 markNeededLazyDep(b, pkg_hash);
                 return null;
             }
-            return dependencyInner(b, name, pkg.build_root, if (@hasDecl(pkg, "build_zig")) pkg.build_zig else null, pkg.deps, args);
+            return dependencyInner(b, name, pkg.build_root, if (@hasDecl(pkg, "build_zig")) pkg.build_zig else null, pkg_hash, pkg.deps, args);
         }
     }
 @@ -1879,13 +1905,48 @@ pub fn dependency(b: *Build, name: []const u8, args: anytype) *Dependency {
             if (@hasDecl(pkg, "available")) {
                 std.debug.panic("dependency '{s}{s}' is marked as lazy in build.zig.zon which means it must use the lazyDependency function instead", .{ b.dep_prefix, name });
             }
-            return dependencyInner(b, name, pkg.build_root, if (@hasDecl(pkg, "build_zig")) pkg.build_zig else null, pkg.deps, args);
+            return dependencyInner(b, name, pkg.build_root, if (@hasDecl(pkg, "build_zig")) pkg.build_zig else null, pkg_hash, pkg.deps, args);
         }
     }
     unreachable; // Bad @dependencies source
 }
+/// In a build.zig file, this function is to `@import` what `lazyDependency` is to `dependency`.
+/// If the dependency is lazy and has not yet been fetched, it instructs the parent process to fetch
+/// that dependency after the build script has finished running, then returns `null`.
+/// If the dependency is lazy but has already been fetched, or if it is eager, it returns
+/// the build.zig struct of that dependency, just like a regular `@import`.
+pub inline fn lazyImport(
+    b: *Build,
+    /// The build.zig struct of the package importing the dependency.
+    /// When calling this function from the `build` function of a build.zig file's, you normally
+    /// pass `@This()`.
+    comptime asking_build_zig: type,
+    comptime dep_name: []const u8,
+) ?type {
+    const build_runner = @import("root");
+    const deps = build_runner.dependencies;
+    const pkg_hash = findImportPkgHashOrFatal(b, asking_build_zig, dep_name);
+    inline for (@typeInfo(deps.packages).Struct.decls) |decl| {
+        if (comptime mem.eql(u8, decl.name, pkg_hash)) {
+            const pkg = @field(deps.packages, decl.name);
+            const available = !@hasDecl(pkg, "available") or pkg.available;
+            if (!available) {
+                markNeededLazyDep(b, pkg_hash);
+                return null;
+            }
+            return if (@hasDecl(pkg, "build_zig"))
+                pkg.build_zig
+            else
+                @compileError("dependency '" ++ dep_name ++ "' does not have a build.zig");
+        }
+    }
+    comptime unreachable; // Bad @dependencies source
+}
 pub fn anonymousDependency(
     b: *Build,
     /// The path to the directory containing the dependency's build.zig file,
 @@ -1902,7 +1963,7 @@ pub fn anonymousDependency(
         '/', '\\' => byte.* = '.',
         else => continue,
     };
-    return dependencyInner(b, name, build_root, build_zig, &.{}, args);
+    return dependencyInner(b, name, build_root, build_zig, "anonymous", &.{}, args);
 }
 fn userValuesAreSame(lhs: UserValue, rhs: UserValue) bool {
 @@ -1957,6 +2018,7 @@ pub fn dependencyInner(
     name: []const u8,
     build_root_string: []const u8,
     comptime build_zig: ?type,
+    pkg_hash: []const u8,
     pkg_deps: AvailableDeps,
     args: anytype,
 ) *Dependency {
 @@ -1977,7 +2039,7 @@ pub fn dependencyInner(
         },
     };
-    const sub_builder = b.createChild(name, build_root, pkg_deps, user_input_options) catch @panic("unhandled error");
+    const sub_builder = b.createChild(name, build_root, pkg_hash, pkg_deps, user_input_options) catch @panic("unhandled error");
     if (build_zig) |bz| {
         sub_builder.runBuild(bz) catch @panic("unhandled error");

lib/std/math/nextafter.zig+1-1

...	@@ -144,7 +144,7 @@ test "int" {	...	@@ -144,7 +144,7 @@ test "int" {
144	}	144	}
145		145
146	test "float" {	146	test "float" {
147	@setEvalBranchQuota(2000);	147	@setEvalBranchQuota(3000);
148		148
149	// normal -> normal	149	// normal -> normal
150	try expect(nextAfter(f16, 0x1.234p0, 2.0) == 0x1.238p0);	150	try expect(nextAfter(f16, 0x1.234p0, 2.0) == 0x1.238p0);

src/Sema.zig+3-3

 @@ -7531,10 +7531,12 @@ fn analyzeCall(
     var is_generic_call = func_ty_info.is_generic;
     var is_comptime_call = block.is_comptime or modifier == .compile_time;
+    var is_inline_call = is_comptime_call or modifier == .always_inline or func_ty_info.cc == .Inline;
     var comptime_reason: ?*const Block.ComptimeReason = null;
-    if (!is_comptime_call) {
+    if (!is_inline_call and !is_comptime_call) {
         if (sema.typeRequiresComptime(Type.fromInterned(func_ty_info.return_type))) |ct| {
             is_comptime_call = ct;
+            is_inline_call = ct;
             if (ct) {
                 comptime_reason = &.{ .comptime_ret_ty = .{
                     .block = block,
 @@ -7548,8 +7550,6 @@ fn analyzeCall(
             else => |e| return e,
         }
     }
-    var is_inline_call = is_comptime_call or modifier == .always_inline or
-        func_ty_info.cc == .Inline;
     if (sema.func_is_naked and !is_inline_call and !is_comptime_call) {
         const msg = msg: {

test/behavior/fn.zig+14

...	@@ -604,3 +604,17 @@ test "comptime parameters don't have to be marked comptime if only called at com	...	@@ -604,3 +604,17 @@ test "comptime parameters don't have to be marked comptime if only called at com
604	};	604	};
605	comptime std.debug.assert(S.foo(5, 6) == 11);	605	comptime std.debug.assert(S.foo(5, 6) == 11);
606	}	606	}
		607
		608	test "inline function with comptime-known comptime-only return type called at runtime" {
		609	const S = struct {
		610	inline fn foo(x: i32, y: const i32) type {
		611	x.* = y.*;
		612	return f32;
		613	}
		614	};
		615	var a: i32 = 0;
		616	const b: i32 = 111;
		617	const T = S.foo(&a, &b);
		618	try expectEqual(111, a);
		619	try expectEqual(f32, T);
		620	}