rework zig env

Introduce introspect.EnvVar which tracks all the environment variables
that are observed by the compiler, so that we can print them with `zig
env`.

The `zig env` command now prints both the resolved values as well as all
the possibly observed environment variables.

1 files changed, 29 insertions, 39 deletions

diff --git a/src/print_env.zig b/src/print_env.zig
index fcfc3f3aeb..ca64889848 100644
--- a/src/print_env.zig
+++ b/src/print_env.zig
@@ -1,62 +1,52 @@
 const std = @import("std");
-const mem = std.mem;
 const build_options = @import("build_options");
 const introspect = @import("introspect.zig");
 const Allocator = std.mem.Allocator;
 const fatal = @import("main.zig").fatal;
 
-const Env = struct {
-    name: []const u8,
-    value: []const u8,
-};
+pub fn cmdEnv(arena: Allocator, args: []const []const u8, stdout: std.fs.File.Writer) !void {
+    _ = args;
+    const self_exe_path = try introspect.findZigExePath(arena);
 
-pub fn cmdEnv(gpa: Allocator, args: []const []const u8, stdout: std.fs.File.Writer) !void {
-    const self_exe_path = try introspect.findZigExePath(gpa);
-    defer gpa.free(self_exe_path);
-
-    var zig_lib_directory = introspect.findZigLibDirFromSelfExe(gpa, self_exe_path) catch |err| {
+    var zig_lib_directory = introspect.findZigLibDirFromSelfExe(arena, self_exe_path) catch |err| {
         fatal("unable to find zig installation directory: {s}\n", .{@errorName(err)});
     };
-    defer gpa.free(zig_lib_directory.path.?);
     defer zig_lib_directory.handle.close();
 
-    const zig_std_dir = try std.fs.path.join(gpa, &[_][]const u8{ zig_lib_directory.path.?, "std" });
-    defer gpa.free(zig_std_dir);
+    const zig_std_dir = try std.fs.path.join(arena, &[_][]const u8{ zig_lib_directory.path.?, "std" });
 
-    const global_cache_dir = try introspect.resolveGlobalCacheDir(gpa);
-    defer gpa.free(global_cache_dir);
+    const global_cache_dir = try introspect.resolveGlobalCacheDir(arena);
 
     const info = try std.zig.system.NativeTargetInfo.detect(.{});
-    const triple = try info.target.zigTriple(gpa);
-    defer gpa.free(triple);
-
-    const envars: []Env = &[_]Env{
-        .{ .name = "zig_exe", .value = self_exe_path },
-        .{ .name = "lib_dir", .value = zig_lib_directory.path.? },
-        .{ .name = "std_dir", .value = zig_std_dir },
-        .{ .name = "global_cache_dir", .value = global_cache_dir },
-        .{ .name = "version", .value = build_options.version },
-        .{ .name = "target", .value = triple },
-    };
+    const triple = try info.target.zigTriple(arena);
 
     var bw = std.io.bufferedWriter(stdout);
     const w = bw.writer();
 
-    if (args.len > 0) {
-        for (args) |name| {
-            for (envars) |env| {
-                if (mem.eql(u8, name, env.name)) {
-                    try w.print("{s}\n", .{env.value});
-                }
-            }
+    try w.print(
+        \\zig_exe={s}
+        \\lib_dir={s}
+        \\std_dir={s}
+        \\global_cache_dir={s}
+        \\version={s}
+        \\target={s}
+        \\
+    , .{
+        self_exe_path,
+        zig_lib_directory.path.?,
+        zig_std_dir,
+        global_cache_dir,
+        build_options.version,
+        triple,
+    });
+
+    inline for (@typeInfo(introspect.EnvVar).Enum.fields) |field| {
+        if (try @field(introspect.EnvVar, field.name).get(arena)) |value| {
+            try w.print("{s}={s}\n", .{ field.name, value });
+        } else {
+            try w.print("{s}\n", .{field.name});
         }
-        try bw.flush();
-
-        return;
     }
 
-    for (envars) |env| {
-        try w.print("{[name]s}=\"{[value]s}\"\n", env);
-    }
     try bw.flush();
 }