GNU bug report logs - #53350
[PATCH] gnu: zig: Update to 0.9.0

Previous Next

Package: guix-patches;

Reported by: Calum Irwin <calumirwin1 <at> gmail.com>

Date: Tue, 18 Jan 2022 19:12:01 UTC

Severity: normal

Tags: patch

Done: Ludovic Courtès <ludo <at> gnu.org>

Bug is archived. No further changes may be made.

To add a comment to this bug, you must first unarchive it, by sending
a message to control AT debbugs.gnu.org, with unarchive 53350 in the body.
You can then email your comments to 53350 AT debbugs.gnu.org in the normal way.

Toggle the display of automated, internal messages from the tracker.

View this report as an mbox folder, status mbox, maintainer mbox


Report forwarded to guix-patches <at> gnu.org:
bug#53350; Package guix-patches. (Tue, 18 Jan 2022 19:12:02 GMT) Full text and rfc822 format available.

Acknowledgement sent to Calum Irwin <calumirwin1 <at> gmail.com>:
New bug report received and forwarded. Copy sent to guix-patches <at> gnu.org. (Tue, 18 Jan 2022 19:12:02 GMT) Full text and rfc822 format available.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Calum Irwin <calumirwin1 <at> gmail.com>
To: guix-patches <at> gnu.org
Cc: Calum Irwin <calumirwin1 <at> gmail.com>
Subject: [PATCH] gnu: zig: Update to 0.9.0
Date: Wed, 19 Jan 2022 08:11:25 +0000
* gnu/packages/patches/zig-disable-libc-note-test.patch: Move patch changes to new file.
* gnu/packages/patches/zig-use-system-paths.patch: Update line numbers.
* gnu/packages/zig.scm: Update to 0.9.0
---
 .../patches/zig-disable-libc-note-test.patch  |  32 +--
 .../patches/zig-use-system-paths.patch        | 261 +++++++++---------
 gnu/packages/zig.scm                          |  11 +-
 3 files changed, 152 insertions(+), 152 deletions(-)

diff --git a/gnu/packages/patches/zig-disable-libc-note-test.patch b/gnu/packages/patches/zig-disable-libc-note-test.patch
index 4d76139efb..b2c57cb571 100644
--- a/gnu/packages/patches/zig-disable-libc-note-test.patch
+++ b/gnu/packages/patches/zig-disable-libc-note-test.patch
@@ -1,14 +1,12 @@
-This test fails with "error.CompilationIncorrectlySucceeded".
-
 diff --git a/test/compile_errors.zig b/test/compile_errors.zig
-index fd1255c..20d5548 100644
+index b1eaa0302..621f9db0a 100644
 --- a/test/compile_errors.zig
 +++ b/test/compile_errors.zig
-@@ -2751,15 +2751,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
+@@ -2943,15 +2943,15 @@ pub fn addCases(ctx: *TestContext) !void {
              "tmp.zig:3:5: error: dependency on libc must be explicitly specified in the build command",
          });
-
--        cases.addTest("libc headers note",
+ 
+-        ctx.testErrStage1("libc headers note",
 -            \\const c = @cImport(@cInclude("stdio.h"));
 -            \\export fn entry() void {
 -            \\    _ = c.printf("hello, world!\n");
@@ -17,15 +15,15 @@ index fd1255c..20d5548 100644
 -            "tmp.zig:1:11: error: C import failed",
 -            "tmp.zig:1:11: note: libc headers not available; compilation does not link against libc",
 -        });
-+//        cases.addTest("libc headers note",
-+//            \\const c = @cImport(@cInclude("stdio.h"));
-+//            \\export fn entry() void {
-+//            \\    _ = c.printf("hello, world!\n");
-+//            \\}
-+//        , &[_][]const u8{
-+//            "tmp.zig:1:11: error: C import failed",
-+//            "tmp.zig:1:11: note: libc headers not available; compilation does not link against libc",
-+//        });
++        // ctx.testErrStage1("libc headers note",
++        //     \\const c = @cImport(@cInclude("stdio.h"));
++        //     \\export fn entry() void {
++        //     \\    _ = c.printf("hello, world!\n");
++        //     \\}
++        // , &[_][]const u8{
++        //     "tmp.zig:1:11: error: C import failed",
++        //     "tmp.zig:1:11: note: libc headers not available; compilation does not link against libc",
++        // });
      }
-
-     cases.addTest("comptime vector overflow shows the index",
+ 
+     ctx.testErrStage1("comptime vector overflow shows the index",
diff --git a/gnu/packages/patches/zig-use-system-paths.patch b/gnu/packages/patches/zig-use-system-paths.patch
index 33b7da1e0d..0a3cbb0e92 100644
--- a/gnu/packages/patches/zig-use-system-paths.patch
+++ b/gnu/packages/patches/zig-use-system-paths.patch
@@ -1,143 +1,144 @@
-This patch replaces the OS-specific detection mechanism by one that solely
-relies on environment variables.  This has the benefit that said environment
-variables can be used as search paths in Guix.
-
-Index: zig-0.8.1/lib/std/zig/system.zig
-===================================================================
---- zig-0.8.1.orig/lib/std/zig/system.zig
-+++ zig-0.8.1/lib/std/zig/system.zig
-@@ -39,101 +39,57 @@ pub const NativePaths = struct {
-         };
-         errdefer self.deinit();
-
--        var is_nix = false;
--        if (process.getEnvVarOwned(allocator, "NIX_CFLAGS_COMPILE")) |nix_cflags_compile| {
--            defer allocator.free(nix_cflags_compile);
+diff --git a/lib/std/zig/system/NativePaths.zig b/lib/std/zig/system/NativePaths.zig
+index 8e3e46e48..1ed9d3206 100644
+--- a/lib/std/zig/system/NativePaths.zig
++++ b/lib/std/zig/system/NativePaths.zig
+@@ -26,73 +26,42 @@ pub fn detect(allocator: Allocator, native_info: NativeTargetInfo) !NativePaths
+     };
+     errdefer self.deinit();
+ 
+-    var is_nix = false;
+-    if (process.getEnvVarOwned(allocator, "NIX_CFLAGS_COMPILE")) |nix_cflags_compile| {
+-        defer allocator.free(nix_cflags_compile);
 -
--            is_nix = true;
--            var it = mem.tokenize(nix_cflags_compile, " ");
-+        // TODO: Support cross-compile paths?
-+        if (process.getEnvVarOwned(allocator, "C_INCLUDE_PATH")) |c_include_path| {
-+            defer allocator.free(c_include_path);
-+            var it = mem.tokenize(c_include_path, ":");
-             while (true) {
--                const word = it.next() orelse break;
--                if (mem.eql(u8, word, "-isystem")) {
--                    const include_path = it.next() orelse {
--                        try self.addWarning("Expected argument after -isystem in NIX_CFLAGS_COMPILE");
--                        break;
--                    };
--                    try self.addIncludeDir(include_path);
--                } else {
--                    if (mem.startsWith(u8, word, "-frandom-seed=")) {
--                        continue;
--                    }
--                    try self.addWarningFmt("Unrecognized C flag from NIX_CFLAGS_COMPILE: {s}", .{word});
+-        is_nix = true;
+-        var it = mem.tokenize(u8, nix_cflags_compile, " ");
++    // TODO: Support cross-compile paths?
++    if (process.getEnvVarOwned(allocator, "C_INCLUDE_PATH")) |c_include_path| {
++        defer allocator.free(c_include_path);
++        var it = mem.tokenize(u8, c_include_path, ":");
+         while (true) {
+-            const word = it.next() orelse break;
+-            if (mem.eql(u8, word, "-isystem")) {
+-                const include_path = it.next() orelse {
+-                    try self.addWarning("Expected argument after -isystem in NIX_CFLAGS_COMPILE");
+-                    break;
+-                };
+-                try self.addIncludeDir(include_path);
+-            } else {
+-                if (mem.startsWith(u8, word, "-frandom-seed=")) {
+-                    continue;
 -                }
-+                const dir = it.next() orelse break;
-+                try self.addIncludeDir(dir);
-             }
-         } else |err| switch (err) {
-             error.InvalidUtf8 => {},
-             error.EnvironmentVariableNotFound => {},
-             error.OutOfMemory => |e| return e,
+-                try self.addWarningFmt("Unrecognized C flag from NIX_CFLAGS_COMPILE: {s}", .{word});
+-            }
++            const dir = it.next() orelse break;
++            try self.addIncludeDir(dir);
          }
--        if (process.getEnvVarOwned(allocator, "NIX_LDFLAGS")) |nix_ldflags| {
--            defer allocator.free(nix_ldflags);
-
--            is_nix = true;
--            var it = mem.tokenize(nix_ldflags, " ");
-+        if (process.getEnvVarOwned(allocator, "CPLUS_INCLUDE_PATH")) |cplus_include_path| {
-+            defer allocator.free(cplus_include_path);
-+            var it = mem.tokenize(cplus_include_path, ":");
-             while (true) {
--                const word = it.next() orelse break;
--                if (mem.eql(u8, word, "-rpath")) {
--                    const rpath = it.next() orelse {
--                        try self.addWarning("Expected argument after -rpath in NIX_LDFLAGS");
--                        break;
--                    };
--                    try self.addRPath(rpath);
--                } else if (word.len > 2 and word[0] == '-' and word[1] == 'L') {
--                    const lib_path = word[2..];
--                    try self.addLibDir(lib_path);
--                } else {
--                    try self.addWarningFmt("Unrecognized C flag from NIX_LDFLAGS: {s}", .{word});
+     } else |err| switch (err) {
+         error.InvalidUtf8 => {},
+         error.EnvironmentVariableNotFound => {},
+         error.OutOfMemory => |e| return e,
+     }
+-    if (process.getEnvVarOwned(allocator, "NIX_LDFLAGS")) |nix_ldflags| {
+-        defer allocator.free(nix_ldflags);
+-
+-        is_nix = true;
+-        var it = mem.tokenize(u8, nix_ldflags, " ");
++    if (process.getEnvVarOwned(allocator, "CPLUS_INCLUDE_PATH")) |cplus_include_path| {
++        defer allocator.free(cplus_include_path);
++        var it = mem.tokenize(u8, cplus_include_path, ":");
+         while (true) {
+-            const word = it.next() orelse break;
+-            if (mem.eql(u8, word, "-rpath")) {
+-                const rpath = it.next() orelse {
+-                    try self.addWarning("Expected argument after -rpath in NIX_LDFLAGS");
 -                    break;
--                }
-+                const dir = it.next() orelse break;
-+                try self.addIncludeDir(dir);
-             }
-         } else |err| switch (err) {
-             error.InvalidUtf8 => {},
-             error.EnvironmentVariableNotFound => {},
-             error.OutOfMemory => |e| return e,
+-                };
+-                try self.addRPath(rpath);
+-            } else if (word.len > 2 and word[0] == '-' and word[1] == 'L') {
+-                const lib_path = word[2..];
+-                try self.addLibDir(lib_path);
+-            } else {
+-                try self.addWarningFmt("Unrecognized C flag from NIX_LDFLAGS: {s}", .{word});
+-                break;
+-            }
++            const dir = it.next() orelse break;
++            try self.addIncludeDir(dir);
          }
--        if (is_nix) {
--            return self;
--        }
+     } else |err| switch (err) {
+         error.InvalidUtf8 => {},
+         error.EnvironmentVariableNotFound => {},
+         error.OutOfMemory => |e| return e,
+     }
+-    if (is_nix) {
+-        return self;
+-    }
 -
--        if (comptime Target.current.isDarwin()) {
--            try self.addIncludeDir("/usr/include");
--            try self.addIncludeDir("/usr/local/include");
-
--            try self.addLibDir("/usr/lib");
--            try self.addLibDir("/usr/local/lib");
+-    if (comptime builtin.target.isDarwin()) {
+-        try self.addIncludeDir("/usr/include");
+-        try self.addIncludeDir("/usr/local/include");
 -
--            try self.addFrameworkDir("/Library/Frameworks");
--            try self.addFrameworkDir("/System/Library/Frameworks");
+-        try self.addLibDir("/usr/lib");
+-        try self.addLibDir("/usr/local/lib");
 -
--            return self;
-+        if (process.getEnvVarOwned(allocator, "LIBRARY_PATH")) |library_path| {
-+            defer allocator.free(library_path);
-+            var it = mem.tokenize(library_path, ":");
-+            while (true) {
-+                const dir = it.next() orelse break;
-+                try self.addLibDir(dir);
-+            }
-+        } else |err| switch (err) {
-+            error.InvalidUtf8 => {},
-+            error.EnvironmentVariableNotFound => {},
-+            error.OutOfMemory => |e| return e,
-         }
-
--        if (native_target.os.tag != .windows) {
--            const triple = try native_target.linuxTriple(allocator);
--            const qual = native_target.cpu.arch.ptrBitWidth();
+-        try self.addFrameworkDir("/Library/Frameworks");
+-        try self.addFrameworkDir("/System/Library/Frameworks");
 -
--            // TODO: $ ld --verbose | grep SEARCH_DIR
--            // the output contains some paths that end with lib64, maybe include them too?
--            // TODO: what is the best possible order of things?
--            // TODO: some of these are suspect and should only be added on some systems. audit needed.
+-        return self;
++    if (process.getEnvVarOwned(allocator, "LIBRARY_PATH")) |library_path| {
++        defer allocator.free(library_path);
++        var it = mem.tokenize(u8, library_path, ":");
++        while (true) {
++            const dir = it.next() orelse break;
++            try self.addLibDir(dir);
++        }
++    } else |err| switch (err) {
++        error.InvalidUtf8 => {},
++        error.EnvironmentVariableNotFound => {},
++        error.OutOfMemory => |e| return e,
+     }
+ 
+     if (comptime native_target.os.tag == .solaris) {
+@@ -106,32 +75,17 @@ pub fn detect(allocator: Allocator, native_info: NativeTargetInfo) !NativePaths
+         return self;
+     }
+ 
+-    if (native_target.os.tag != .windows) {
+-        const triple = try native_target.linuxTriple(allocator);
+-        const qual = native_target.cpu.arch.ptrBitWidth();
 -
--            try self.addIncludeDir("/usr/local/include");
--            try self.addLibDirFmt("/usr/local/lib{d}", .{qual});
--            try self.addLibDir("/usr/local/lib");
+-        // TODO: $ ld --verbose | grep SEARCH_DIR
+-        // the output contains some paths that end with lib64, maybe include them too?
+-        // TODO: what is the best possible order of things?
+-        // TODO: some of these are suspect and should only be added on some systems. audit needed.
 -
--            try self.addIncludeDirFmt("/usr/include/{s}", .{triple});
--            try self.addLibDirFmt("/usr/lib/{s}", .{triple});
+-        try self.addIncludeDir("/usr/local/include");
+-        try self.addLibDirFmt("/usr/local/lib{d}", .{qual});
+-        try self.addLibDir("/usr/local/lib");
 -
--            try self.addIncludeDir("/usr/include");
--            try self.addLibDirFmt("/lib{d}", .{qual});
--            try self.addLibDir("/lib");
--            try self.addLibDirFmt("/usr/lib{d}", .{qual});
--            try self.addLibDir("/usr/lib");
+-        try self.addIncludeDirFmt("/usr/include/{s}", .{triple});
+-        try self.addLibDirFmt("/usr/lib/{s}", .{triple});
 -
--            // example: on a 64-bit debian-based linux distro, with zlib installed from apt:
--            // zlib.h is in /usr/include (added above)
--            // libz.so.1 is in /lib/x86_64-linux-gnu (added here)
--            try self.addLibDirFmt("/lib/{s}", .{triple});
-+        if (process.getEnvVarOwned(allocator, "DYLD_FRAMEWORK_PATH")) |dyld_framework_path| {
-+            defer allocator.free(dyld_framework_path);
-+            var it = mem.tokenize(dyld_framework_path, ":");
-+            while (true) {
-+                const dir = it.next() orelse break;
-+                try self.addFrameworkDir(dir);
-+            }
-+        } else |err| switch (err) {
-+            error.InvalidUtf8 => {},
-+            error.EnvironmentVariableNotFound => {},
-+            error.OutOfMemory => |e| return e,
-         }
-
-         return self;
+-        try self.addIncludeDir("/usr/include");
+-        try self.addLibDirFmt("/lib{d}", .{qual});
+-        try self.addLibDir("/lib");
+-        try self.addLibDirFmt("/usr/lib{d}", .{qual});
+-        try self.addLibDir("/usr/lib");
+-
+-        // example: on a 64-bit debian-based linux distro, with zlib installed from apt:
+-        // zlib.h is in /usr/include (added above)
+-        // libz.so.1 is in /lib/x86_64-linux-gnu (added here)
+-        try self.addLibDirFmt("/lib/{s}", .{triple});
++    if (process.getEnvVarOwned(allocator, "DYLD_FRAMEWORK_PATH")) |dyld_framework_path| {
++        defer allocator.free(dyld_framework_path);
++        var it = mem.tokenize(u8, dyld_framework_path, ":");
++        while (true) {
++            const dir = it.next() orelse break;
++            try self.addFrameworkDir(dir);
++        }
++    } else |err| switch (err) {
++        error.InvalidUtf8 => {},
++        error.EnvironmentVariableNotFound => {},
++        error.OutOfMemory => |e| return e,
+     }
+ 
+     return self;
diff --git a/gnu/packages/zig.scm b/gnu/packages/zig.scm
index 9cd869389b..b3de72226b 100644
--- a/gnu/packages/zig.scm
+++ b/gnu/packages/zig.scm
@@ -1,6 +1,7 @@
 ;;; GNU Guix --- Functional package management for GNU
 ;;; Copyright © 2021 Liliana Marie Prikler <liliana.prikler <at> gmail.com>
 ;;; Copyright © 2021 Sarah Morgensen <iskarian <at> mgsn.dev>
+;;; Copyright © 2021 Calum Irwin <calumirwin1 <at> gmail.com>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -28,7 +29,7 @@ (define-module (gnu packages zig)
 (define-public zig
   (package
     (name "zig")
-    (version "0.8.1")
+    (version "0.9.0")
     (source
      (origin
        (method git-fetch)
@@ -37,18 +38,18 @@ (define-public zig
              (commit version)))
        (file-name (git-file-name name version))
        (sha256
-        (base32 "147qx7xgj0r353wh5ragzn6kmm1vrf31i8038z3zqwjnqqgqxi6c"))
+        (base32 "1zdz5s434c48z3y0c8l9wm2z1gxa7yyzd53zmr68lwj6mcl7by8x"))
        (patches
         (search-patches
          "zig-disable-libc-note-test.patch"
          "zig-use-system-paths.patch"))))
     (build-system cmake-build-system)
     (inputs
-     (list clang-12 ; Clang propagates llvm.
-           lld-12))
+     (list clang-13 ; Clang propagates llvm.
+           lld))
     ;; Zig compiles fine with GCC, but also needs native LLVM libraries.
     (native-inputs
-     (list llvm-12))
+     (list llvm-13))
     (arguments
      `(#:configure-flags
        (list ,@(if (%current-target-system)
-- 
2.34.1





Information forwarded to guix-patches <at> gnu.org:
bug#53350; Package guix-patches. (Tue, 18 Jan 2022 19:33:01 GMT) Full text and rfc822 format available.

Message #8 received at 53350 <at> debbugs.gnu.org (full text, mbox):

From: Calum Irwin <calumirwin1 <at> gmail.com>
To: 53350 <at> debbugs.gnu.org
Subject: breaking change
Date: Wed, 19 Jan 2022 08:32:14 +0000
By the way, the upgrade from 0.8 to 0.9 includes breaking changes in
the core lib. I figured this isn't an issue since zig isn't used to
build any other packages and it's still a pre-1.0 language.




Information forwarded to guix-patches <at> gnu.org:
bug#53350; Package guix-patches. (Thu, 20 Jan 2022 06:50:01 GMT) Full text and rfc822 format available.

Message #11 received at 53350 <at> debbugs.gnu.org (full text, mbox):

From: pukkamustard <pukkamustard <at> posteo.net>
To: Calum Irwin <calumirwin1 <at> gmail.com>
Cc: 53350 <at> debbugs.gnu.org
Subject: Re: [bug#53350] [PATCH] gnu: zig: Update to 0.9.0
Date: Thu, 20 Jan 2022 06:45:38 +0000
Hi,

I can't comment on the changes to the *.patch changes but I can confirm
that it builds and seems to be working fine.

Thanks!

-pukkamustard


Calum Irwin <calumirwin1 <at> gmail.com> writes:

> * gnu/packages/patches/zig-disable-libc-note-test.patch: Move patch changes to new file.
> * gnu/packages/patches/zig-use-system-paths.patch: Update line numbers.
> * gnu/packages/zig.scm: Update to 0.9.0
> ---
>  .../patches/zig-disable-libc-note-test.patch  |  32 +--
>  .../patches/zig-use-system-paths.patch        | 261 +++++++++---------
>  gnu/packages/zig.scm                          |  11 +-
>  3 files changed, 152 insertions(+), 152 deletions(-)
>
> diff --git a/gnu/packages/patches/zig-disable-libc-note-test.patch b/gnu/packages/patches/zig-disable-libc-note-test.patch
> index 4d76139efb..b2c57cb571 100644
> --- a/gnu/packages/patches/zig-disable-libc-note-test.patch
> +++ b/gnu/packages/patches/zig-disable-libc-note-test.patch
> @@ -1,14 +1,12 @@
> -This test fails with "error.CompilationIncorrectlySucceeded".
> -
>  diff --git a/test/compile_errors.zig b/test/compile_errors.zig
> -index fd1255c..20d5548 100644
> +index b1eaa0302..621f9db0a 100644
>  --- a/test/compile_errors.zig
>  +++ b/test/compile_errors.zig
> -@@ -2751,15 +2751,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
> +@@ -2943,15 +2943,15 @@ pub fn addCases(ctx: *TestContext) !void {
>               "tmp.zig:3:5: error: dependency on libc must be explicitly specified in the build command",
>           });
> -
> --        cases.addTest("libc headers note",
> + 
> +-        ctx.testErrStage1("libc headers note",
>  -            \\const c = @cImport(@cInclude("stdio.h"));
>  -            \\export fn entry() void {
>  -            \\    _ = c.printf("hello, world!\n");
> @@ -17,15 +15,15 @@ index fd1255c..20d5548 100644
>  -            "tmp.zig:1:11: error: C import failed",
>  -            "tmp.zig:1:11: note: libc headers not available; compilation does not link against libc",
>  -        });
> -+//        cases.addTest("libc headers note",
> -+//            \\const c = @cImport(@cInclude("stdio.h"));
> -+//            \\export fn entry() void {
> -+//            \\    _ = c.printf("hello, world!\n");
> -+//            \\}
> -+//        , &[_][]const u8{
> -+//            "tmp.zig:1:11: error: C import failed",
> -+//            "tmp.zig:1:11: note: libc headers not available; compilation does not link against libc",
> -+//        });
> ++        // ctx.testErrStage1("libc headers note",
> ++        //     \\const c = @cImport(@cInclude("stdio.h"));
> ++        //     \\export fn entry() void {
> ++        //     \\    _ = c.printf("hello, world!\n");
> ++        //     \\}
> ++        // , &[_][]const u8{
> ++        //     "tmp.zig:1:11: error: C import failed",
> ++        //     "tmp.zig:1:11: note: libc headers not available; compilation does not link against libc",
> ++        // });
>       }
> -
> -     cases.addTest("comptime vector overflow shows the index",
> + 
> +     ctx.testErrStage1("comptime vector overflow shows the index",
> diff --git a/gnu/packages/patches/zig-use-system-paths.patch b/gnu/packages/patches/zig-use-system-paths.patch
> index 33b7da1e0d..0a3cbb0e92 100644
> --- a/gnu/packages/patches/zig-use-system-paths.patch
> +++ b/gnu/packages/patches/zig-use-system-paths.patch
> @@ -1,143 +1,144 @@
> -This patch replaces the OS-specific detection mechanism by one that solely
> -relies on environment variables.  This has the benefit that said environment
> -variables can be used as search paths in Guix.
> -
> -Index: zig-0.8.1/lib/std/zig/system.zig
> -===================================================================
> ---- zig-0.8.1.orig/lib/std/zig/system.zig
> -+++ zig-0.8.1/lib/std/zig/system.zig
> -@@ -39,101 +39,57 @@ pub const NativePaths = struct {
> -         };
> -         errdefer self.deinit();
> -
> --        var is_nix = false;
> --        if (process.getEnvVarOwned(allocator, "NIX_CFLAGS_COMPILE")) |nix_cflags_compile| {
> --            defer allocator.free(nix_cflags_compile);
> +diff --git a/lib/std/zig/system/NativePaths.zig b/lib/std/zig/system/NativePaths.zig
> +index 8e3e46e48..1ed9d3206 100644
> +--- a/lib/std/zig/system/NativePaths.zig
> ++++ b/lib/std/zig/system/NativePaths.zig
> +@@ -26,73 +26,42 @@ pub fn detect(allocator: Allocator, native_info: NativeTargetInfo) !NativePaths
> +     };
> +     errdefer self.deinit();
> + 
> +-    var is_nix = false;
> +-    if (process.getEnvVarOwned(allocator, "NIX_CFLAGS_COMPILE")) |nix_cflags_compile| {
> +-        defer allocator.free(nix_cflags_compile);
>  -
> --            is_nix = true;
> --            var it = mem.tokenize(nix_cflags_compile, " ");
> -+        // TODO: Support cross-compile paths?
> -+        if (process.getEnvVarOwned(allocator, "C_INCLUDE_PATH")) |c_include_path| {
> -+            defer allocator.free(c_include_path);
> -+            var it = mem.tokenize(c_include_path, ":");
> -             while (true) {
> --                const word = it.next() orelse break;
> --                if (mem.eql(u8, word, "-isystem")) {
> --                    const include_path = it.next() orelse {
> --                        try self.addWarning("Expected argument after -isystem in NIX_CFLAGS_COMPILE");
> --                        break;
> --                    };
> --                    try self.addIncludeDir(include_path);
> --                } else {
> --                    if (mem.startsWith(u8, word, "-frandom-seed=")) {
> --                        continue;
> --                    }
> --                    try self.addWarningFmt("Unrecognized C flag from NIX_CFLAGS_COMPILE: {s}", .{word});
> +-        is_nix = true;
> +-        var it = mem.tokenize(u8, nix_cflags_compile, " ");
> ++    // TODO: Support cross-compile paths?
> ++    if (process.getEnvVarOwned(allocator, "C_INCLUDE_PATH")) |c_include_path| {
> ++        defer allocator.free(c_include_path);
> ++        var it = mem.tokenize(u8, c_include_path, ":");
> +         while (true) {
> +-            const word = it.next() orelse break;
> +-            if (mem.eql(u8, word, "-isystem")) {
> +-                const include_path = it.next() orelse {
> +-                    try self.addWarning("Expected argument after -isystem in NIX_CFLAGS_COMPILE");
> +-                    break;
> +-                };
> +-                try self.addIncludeDir(include_path);
> +-            } else {
> +-                if (mem.startsWith(u8, word, "-frandom-seed=")) {
> +-                    continue;
>  -                }
> -+                const dir = it.next() orelse break;
> -+                try self.addIncludeDir(dir);
> -             }
> -         } else |err| switch (err) {
> -             error.InvalidUtf8 => {},
> -             error.EnvironmentVariableNotFound => {},
> -             error.OutOfMemory => |e| return e,
> +-                try self.addWarningFmt("Unrecognized C flag from NIX_CFLAGS_COMPILE: {s}", .{word});
> +-            }
> ++            const dir = it.next() orelse break;
> ++            try self.addIncludeDir(dir);
>           }
> --        if (process.getEnvVarOwned(allocator, "NIX_LDFLAGS")) |nix_ldflags| {
> --            defer allocator.free(nix_ldflags);
> -
> --            is_nix = true;
> --            var it = mem.tokenize(nix_ldflags, " ");
> -+        if (process.getEnvVarOwned(allocator, "CPLUS_INCLUDE_PATH")) |cplus_include_path| {
> -+            defer allocator.free(cplus_include_path);
> -+            var it = mem.tokenize(cplus_include_path, ":");
> -             while (true) {
> --                const word = it.next() orelse break;
> --                if (mem.eql(u8, word, "-rpath")) {
> --                    const rpath = it.next() orelse {
> --                        try self.addWarning("Expected argument after -rpath in NIX_LDFLAGS");
> --                        break;
> --                    };
> --                    try self.addRPath(rpath);
> --                } else if (word.len > 2 and word[0] == '-' and word[1] == 'L') {
> --                    const lib_path = word[2..];
> --                    try self.addLibDir(lib_path);
> --                } else {
> --                    try self.addWarningFmt("Unrecognized C flag from NIX_LDFLAGS: {s}", .{word});
> +     } else |err| switch (err) {
> +         error.InvalidUtf8 => {},
> +         error.EnvironmentVariableNotFound => {},
> +         error.OutOfMemory => |e| return e,
> +     }
> +-    if (process.getEnvVarOwned(allocator, "NIX_LDFLAGS")) |nix_ldflags| {
> +-        defer allocator.free(nix_ldflags);
> +-
> +-        is_nix = true;
> +-        var it = mem.tokenize(u8, nix_ldflags, " ");
> ++    if (process.getEnvVarOwned(allocator, "CPLUS_INCLUDE_PATH")) |cplus_include_path| {
> ++        defer allocator.free(cplus_include_path);
> ++        var it = mem.tokenize(u8, cplus_include_path, ":");
> +         while (true) {
> +-            const word = it.next() orelse break;
> +-            if (mem.eql(u8, word, "-rpath")) {
> +-                const rpath = it.next() orelse {
> +-                    try self.addWarning("Expected argument after -rpath in NIX_LDFLAGS");
>  -                    break;
> --                }
> -+                const dir = it.next() orelse break;
> -+                try self.addIncludeDir(dir);
> -             }
> -         } else |err| switch (err) {
> -             error.InvalidUtf8 => {},
> -             error.EnvironmentVariableNotFound => {},
> -             error.OutOfMemory => |e| return e,
> +-                };
> +-                try self.addRPath(rpath);
> +-            } else if (word.len > 2 and word[0] == '-' and word[1] == 'L') {
> +-                const lib_path = word[2..];
> +-                try self.addLibDir(lib_path);
> +-            } else {
> +-                try self.addWarningFmt("Unrecognized C flag from NIX_LDFLAGS: {s}", .{word});
> +-                break;
> +-            }
> ++            const dir = it.next() orelse break;
> ++            try self.addIncludeDir(dir);
>           }
> --        if (is_nix) {
> --            return self;
> --        }
> +     } else |err| switch (err) {
> +         error.InvalidUtf8 => {},
> +         error.EnvironmentVariableNotFound => {},
> +         error.OutOfMemory => |e| return e,
> +     }
> +-    if (is_nix) {
> +-        return self;
> +-    }
>  -
> --        if (comptime Target.current.isDarwin()) {
> --            try self.addIncludeDir("/usr/include");
> --            try self.addIncludeDir("/usr/local/include");
> -
> --            try self.addLibDir("/usr/lib");
> --            try self.addLibDir("/usr/local/lib");
> +-    if (comptime builtin.target.isDarwin()) {
> +-        try self.addIncludeDir("/usr/include");
> +-        try self.addIncludeDir("/usr/local/include");
>  -
> --            try self.addFrameworkDir("/Library/Frameworks");
> --            try self.addFrameworkDir("/System/Library/Frameworks");
> +-        try self.addLibDir("/usr/lib");
> +-        try self.addLibDir("/usr/local/lib");
>  -
> --            return self;
> -+        if (process.getEnvVarOwned(allocator, "LIBRARY_PATH")) |library_path| {
> -+            defer allocator.free(library_path);
> -+            var it = mem.tokenize(library_path, ":");
> -+            while (true) {
> -+                const dir = it.next() orelse break;
> -+                try self.addLibDir(dir);
> -+            }
> -+        } else |err| switch (err) {
> -+            error.InvalidUtf8 => {},
> -+            error.EnvironmentVariableNotFound => {},
> -+            error.OutOfMemory => |e| return e,
> -         }
> -
> --        if (native_target.os.tag != .windows) {
> --            const triple = try native_target.linuxTriple(allocator);
> --            const qual = native_target.cpu.arch.ptrBitWidth();
> +-        try self.addFrameworkDir("/Library/Frameworks");
> +-        try self.addFrameworkDir("/System/Library/Frameworks");
>  -
> --            // TODO: $ ld --verbose | grep SEARCH_DIR
> --            // the output contains some paths that end with lib64, maybe include them too?
> --            // TODO: what is the best possible order of things?
> --            // TODO: some of these are suspect and should only be added on some systems. audit needed.
> +-        return self;
> ++    if (process.getEnvVarOwned(allocator, "LIBRARY_PATH")) |library_path| {
> ++        defer allocator.free(library_path);
> ++        var it = mem.tokenize(u8, library_path, ":");
> ++        while (true) {
> ++            const dir = it.next() orelse break;
> ++            try self.addLibDir(dir);
> ++        }
> ++    } else |err| switch (err) {
> ++        error.InvalidUtf8 => {},
> ++        error.EnvironmentVariableNotFound => {},
> ++        error.OutOfMemory => |e| return e,
> +     }
> + 
> +     if (comptime native_target.os.tag == .solaris) {
> +@@ -106,32 +75,17 @@ pub fn detect(allocator: Allocator, native_info: NativeTargetInfo) !NativePaths
> +         return self;
> +     }
> + 
> +-    if (native_target.os.tag != .windows) {
> +-        const triple = try native_target.linuxTriple(allocator);
> +-        const qual = native_target.cpu.arch.ptrBitWidth();
>  -
> --            try self.addIncludeDir("/usr/local/include");
> --            try self.addLibDirFmt("/usr/local/lib{d}", .{qual});
> --            try self.addLibDir("/usr/local/lib");
> +-        // TODO: $ ld --verbose | grep SEARCH_DIR
> +-        // the output contains some paths that end with lib64, maybe include them too?
> +-        // TODO: what is the best possible order of things?
> +-        // TODO: some of these are suspect and should only be added on some systems. audit needed.
>  -
> --            try self.addIncludeDirFmt("/usr/include/{s}", .{triple});
> --            try self.addLibDirFmt("/usr/lib/{s}", .{triple});
> +-        try self.addIncludeDir("/usr/local/include");
> +-        try self.addLibDirFmt("/usr/local/lib{d}", .{qual});
> +-        try self.addLibDir("/usr/local/lib");
>  -
> --            try self.addIncludeDir("/usr/include");
> --            try self.addLibDirFmt("/lib{d}", .{qual});
> --            try self.addLibDir("/lib");
> --            try self.addLibDirFmt("/usr/lib{d}", .{qual});
> --            try self.addLibDir("/usr/lib");
> +-        try self.addIncludeDirFmt("/usr/include/{s}", .{triple});
> +-        try self.addLibDirFmt("/usr/lib/{s}", .{triple});
>  -
> --            // example: on a 64-bit debian-based linux distro, with zlib installed from apt:
> --            // zlib.h is in /usr/include (added above)
> --            // libz.so.1 is in /lib/x86_64-linux-gnu (added here)
> --            try self.addLibDirFmt("/lib/{s}", .{triple});
> -+        if (process.getEnvVarOwned(allocator, "DYLD_FRAMEWORK_PATH")) |dyld_framework_path| {
> -+            defer allocator.free(dyld_framework_path);
> -+            var it = mem.tokenize(dyld_framework_path, ":");
> -+            while (true) {
> -+                const dir = it.next() orelse break;
> -+                try self.addFrameworkDir(dir);
> -+            }
> -+        } else |err| switch (err) {
> -+            error.InvalidUtf8 => {},
> -+            error.EnvironmentVariableNotFound => {},
> -+            error.OutOfMemory => |e| return e,
> -         }
> -
> -         return self;
> +-        try self.addIncludeDir("/usr/include");
> +-        try self.addLibDirFmt("/lib{d}", .{qual});
> +-        try self.addLibDir("/lib");
> +-        try self.addLibDirFmt("/usr/lib{d}", .{qual});
> +-        try self.addLibDir("/usr/lib");
> +-
> +-        // example: on a 64-bit debian-based linux distro, with zlib installed from apt:
> +-        // zlib.h is in /usr/include (added above)
> +-        // libz.so.1 is in /lib/x86_64-linux-gnu (added here)
> +-        try self.addLibDirFmt("/lib/{s}", .{triple});
> ++    if (process.getEnvVarOwned(allocator, "DYLD_FRAMEWORK_PATH")) |dyld_framework_path| {
> ++        defer allocator.free(dyld_framework_path);
> ++        var it = mem.tokenize(u8, dyld_framework_path, ":");
> ++        while (true) {
> ++            const dir = it.next() orelse break;
> ++            try self.addFrameworkDir(dir);
> ++        }
> ++    } else |err| switch (err) {
> ++        error.InvalidUtf8 => {},
> ++        error.EnvironmentVariableNotFound => {},
> ++        error.OutOfMemory => |e| return e,
> +     }
> + 
> +     return self;
> diff --git a/gnu/packages/zig.scm b/gnu/packages/zig.scm
> index 9cd869389b..b3de72226b 100644
> --- a/gnu/packages/zig.scm
> +++ b/gnu/packages/zig.scm
> @@ -1,6 +1,7 @@
>  ;;; GNU Guix --- Functional package management for GNU
>  ;;; Copyright © 2021 Liliana Marie Prikler <liliana.prikler <at> gmail.com>
>  ;;; Copyright © 2021 Sarah Morgensen <iskarian <at> mgsn.dev>
> +;;; Copyright © 2021 Calum Irwin <calumirwin1 <at> gmail.com>
>  ;;;
>  ;;; This file is part of GNU Guix.
>  ;;;
> @@ -28,7 +29,7 @@ (define-module (gnu packages zig)
>  (define-public zig
>    (package
>      (name "zig")
> -    (version "0.8.1")
> +    (version "0.9.0")
>      (source
>       (origin
>         (method git-fetch)
> @@ -37,18 +38,18 @@ (define-public zig
>               (commit version)))
>         (file-name (git-file-name name version))
>         (sha256
> -        (base32 "147qx7xgj0r353wh5ragzn6kmm1vrf31i8038z3zqwjnqqgqxi6c"))
> +        (base32 "1zdz5s434c48z3y0c8l9wm2z1gxa7yyzd53zmr68lwj6mcl7by8x"))
>         (patches
>          (search-patches
>           "zig-disable-libc-note-test.patch"
>           "zig-use-system-paths.patch"))))
>      (build-system cmake-build-system)
>      (inputs
> -     (list clang-12 ; Clang propagates llvm.
> -           lld-12))
> +     (list clang-13 ; Clang propagates llvm.
> +           lld))
>      ;; Zig compiles fine with GCC, but also needs native LLVM libraries.
>      (native-inputs
> -     (list llvm-12))
> +     (list llvm-13))
>      (arguments
>       `(#:configure-flags
>         (list ,@(if (%current-target-system)





Information forwarded to guix-patches <at> gnu.org:
bug#53350; Package guix-patches. (Mon, 24 Jan 2022 09:34:02 GMT) Full text and rfc822 format available.

Message #14 received at 53350 <at> debbugs.gnu.org (full text, mbox):

From: Ludovic Courtès <ludo <at> gnu.org>
To: Calum Irwin <calumirwin1 <at> gmail.com>
Cc: 53350 <at> debbugs.gnu.org
Subject: Re: bug#53350: [PATCH] gnu: zig: Update to 0.9.0
Date: Mon, 24 Jan 2022 10:32:55 +0100
Hi Calum,

Calum Irwin <calumirwin1 <at> gmail.com> skribis:

> * gnu/packages/patches/zig-disable-libc-note-test.patch: Move patch changes to new file.
> * gnu/packages/patches/zig-use-system-paths.patch: Update line numbers.
> * gnu/packages/zig.scm: Update to 0.9.0

For some reason I can’t seem to apply it:

--8<---------------cut here---------------start------------->8---
$ git am --show-current-patch=diff|patch -p1
patching file gnu/packages/patches/zig-disable-libc-note-test.patch
Hunk #1 FAILED at 1.
1 out of 1 hunk FAILED -- saving rejects to file gnu/packages/patches/zig-disable-libc-note-test.patch.rej
patching file gnu/packages/patches/zig-use-system-paths.patch
patch: **** malformed patch at line 314: -         return self;
--8<---------------cut here---------------end--------------->8---

Could you take a look and resend?

> --- a/gnu/packages/patches/zig-disable-libc-note-test.patch
> +++ b/gnu/packages/patches/zig-disable-libc-note-test.patch
> @@ -1,14 +1,12 @@
> -This test fails with "error.CompilationIncorrectlySucceeded".
> -

[...]

> --- a/gnu/packages/patches/zig-use-system-paths.patch
> +++ b/gnu/packages/patches/zig-use-system-paths.patch
> @@ -1,143 +1,144 @@
> -This patch replaces the OS-specific detection mechanism by one that solely
> -relies on environment variables.  This has the benefit that said environment
> -variables can be used as search paths in Guix.

Also, please preserve those comments at the top of patches.

Thanks in advance,
Ludo’.




Reply sent to Ludovic Courtès <ludo <at> gnu.org>:
You have taken responsibility. (Mon, 24 Jan 2022 14:04:02 GMT) Full text and rfc822 format available.

Notification sent to Calum Irwin <calumirwin1 <at> gmail.com>:
bug acknowledged by developer. (Mon, 24 Jan 2022 14:04:02 GMT) Full text and rfc822 format available.

Message #19 received at 53350-done <at> debbugs.gnu.org (full text, mbox):

From: Ludovic Courtès <ludo <at> gnu.org>
To: Calum Irwin <calumirwin1 <at> gmail.com>
Cc: 53350-done <at> debbugs.gnu.org
Subject: Re: bug#53350: [PATCH] gnu: zig: Update to 0.9.0
Date: Mon, 24 Jan 2022 15:03:20 +0100
Hello,

Ludovic Courtès <ludo <at> gnu.org> skribis:

> Hi Calum,
>
> Calum Irwin <calumirwin1 <at> gmail.com> skribis:
>
>> * gnu/packages/patches/zig-disable-libc-note-test.patch: Move patch changes to new file.
>> * gnu/packages/patches/zig-use-system-paths.patch: Update line numbers.
>> * gnu/packages/zig.scm: Update to 0.9.0
>
> For some reason I can’t seem to apply it:

Following Ricardo’s advice on IRC, I was able to apply it with:

  wget -qO- https://issues.guix.gnu.org/issue/53350/raw/0 \
    | git am --patch-format=mbox -s

Not sure what’s wrong with my Gnus setup…

> Also, please preserve those comments at the top of patches.

I’ve restored them.

Applied, thanks!

Ludo’.




bug archived. Request was from Debbugs Internal Request <help-debbugs <at> gnu.org> to internal_control <at> debbugs.gnu.org. (Tue, 22 Feb 2022 12:24:06 GMT) Full text and rfc822 format available.

This bug report was last modified 2 years and 36 days ago.

Previous Next


GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997,2003 nCipher Corporation Ltd, 1994-97 Ian Jackson.