treewide: buildFlagsArray -> ldflags

pkgs/applications/editors/glow/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags= -s -w -X=main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X=main.Version=${version}" ];
 
   meta = with lib; {
     description = "Render markdown on the CLI, with pizzazz!";

pkgs/applications/editors/micro/default.nix

···
 
   vendorSha256 = "sha256-YcAKl4keizkbgQLAZGiCG3CGpNTNad8EvOJEXLX2s0s=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/zyedidia/micro/v2/internal/util.Version=${version} -X github.com/zyedidia/micro/v2/internal/util.CommitHash=${src.rev}" ];
+  ldflags = [ "-s" "-w" "-X github.com/zyedidia/micro/v2/internal/util.Version=${version}" "-X github.com/zyedidia/micro/v2/internal/util.CommitHash=${src.rev}" ];
 
   postInstall = ''
     installManPage assets/packaging/micro.1

pkgs/applications/logging/humioctl/default.nix

···
       sha256 = sha256;
     };
 
-    buildFlagsArray = "-ldflags=-X main.version=${humioCtlVersion}";
+    ldflags = [ "-X main.version=${humioCtlVersion}" ];
 
     nativeBuildInputs = [ installShellFiles ];
 

pkgs/applications/misc/archiver/default.nix

···
 
   vendorSha256 = "0avnskay23mpl3qkyf1h75rr7szpsxis2bj5pplhwf8q8q0212xf";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version} -X main.commit=${src.rev} -X main.date=unknown" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" "-X main.commit=${src.rev}" "-X main.date=unknown" ];
 
   doCheck = false;
 

pkgs/applications/misc/charm/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags= -s -w -X=main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X=main.Version=${version}" ];
 
   meta = with lib; {
     description = "Manage your charm account on the CLI";

pkgs/applications/misc/dstask/default.nix

···
   # The other variables are set so that the output of dstask version shows the
   # git ref and the release version from github.
   # Ref <https://github.com/NixOS/nixpkgs/pull/87383#discussion_r432097657>
-  buildFlagsArray = [ ''
-    -ldflags=-w -s
-    -X "github.com/naggie/dstask.VERSION=${version}"
-    -X "github.com/naggie/dstask.GIT_COMMIT=v${version}"
-  '' ];
+  ldflags = [
+    "-w" "-s"
+    "-X github.com/naggie/dstask.VERSION=${version}"
+    "-X github.com/naggie/dstask.GIT_COMMIT=v${version}"
+  ];
 
   subPackages = [ "cmd/dstask.go" ];
 

pkgs/applications/misc/expenses/default.nix

···
 
   buildInputs = [ sqlite ];
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X github.com/manojkarthick/expenses/cmd.Version=${version}"
+  ldflags = [
+    "-s" "-w" "-X github.com/manojkarthick/expenses/cmd.Version=${version}"
   ];
 
   meta = with lib; {

pkgs/applications/misc/wtf/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   subPackages = [ "." ];
 

pkgs/applications/networking/cloudflared/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = "-ldflags=-X main.Version=${version}";
+  ldflags = [ "-X main.Version=${version}" ];
 
   meta = with lib; {
     description = "CloudFlare Argo Tunnel daemon (and DNS-over-HTTPS client)";

pkgs/applications/networking/cluster/argocd/default.nix

···
     packr
   '';
 
-  buildFlagsArray =
+  ldflags =
     let package_url = "github.com/argoproj/argo-cd/v2/common"; in
     [
-      "-ldflags="
-      "-s -w"
+      "-s" "-w"
       "-X ${package_url}.version=${version}"
       "-X ${package_url}.buildDate=unknown"
       "-X ${package_url}.gitCommit=${commit}"

pkgs/applications/networking/cluster/cloudfoundry-cli/default.nix

···
 
   nativeBuildInputs = [ installShellFiles ];
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X code.cloudfoundry.org/cli/version.binaryBuildDate=1970-01-01"

pkgs/applications/networking/cluster/fluxcd/default.nix

···
 
   subPackages = [ "cmd/flux" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.VERSION=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.VERSION=${version}" ];
 
   postUnpack = ''
     cp -r ${manifests} source/cmd/flux/manifests

pkgs/applications/networking/cluster/fluxctl/default.nix

···
 
   subPackages = [ "cmd/fluxctl" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   postInstall = ''
     for shell in bash fish zsh; do

pkgs/applications/networking/cluster/helmfile/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/roboll/helmfile/pkg/app/version.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/roboll/helmfile/pkg/app/version.Version=${version}" ];
 
   postInstall = ''
     wrapProgram $out/bin/helmfile \

pkgs/applications/networking/cluster/hetzner-kube/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = ''
-    -ldflags=
-    -X github.com/xetys/hetzner-kube/cmd.version=${version}
-  '';
+  ldflags = [
+    "-X github.com/xetys/hetzner-kube/cmd.version=${version}"
+  ];
 
   nativeBuildInputs = [
     installShellFiles

pkgs/applications/networking/cluster/istioctl/default.nix

···
   nativeBuildInputs = [ installShellFiles ];
 
   # Bundle release metadata
-  buildFlagsArray = let
+  ldflags = let
     attrs = [
       "istio.io/pkg/version.buildVersion=${version}"
       "istio.io/pkg/version.buildStatus=Nix"
       "istio.io/pkg/version.buildTag=${version}"
       "istio.io/pkg/version.buildHub=docker.io/istio"
     ];
-  in ["-ldflags=-s -w ${lib.concatMapStringsSep " " (attr: "-X ${attr}") attrs}"];
+  in ["-s" "-w" "${lib.concatMapStringsSep " " (attr: "-X ${attr}") attrs}"];
 
   subPackages = [ "istioctl/cmd/istioctl" ];
 

pkgs/applications/networking/cluster/jx/default.nix

···
 
   nativeBuildInputs = [ installShellFiles ];
 
-  buildFlagsArray = ''
-    -ldflags=
-    -s -w
-    -X github.com/jenkins-x/jx/pkg/version.Version=${version}
-    -X github.com/jenkins-x/jx/pkg/version.Revision=${src.rev}
-    -X github.com/jenkins-x/jx/pkg/version.GitTreeState=clean
-  '';
+  ldflags = [
+    "-s -w"
+    "-X github.com/jenkins-x/jx/pkg/version.Version=${version}"
+    "-X github.com/jenkins-x/jx/pkg/version.Revision=${src.rev}"
+    "-X github.com/jenkins-x/jx/pkg/version.GitTreeState=clean"
+  ];
 
   postInstall = ''
     for shell in bash zsh; do

pkgs/applications/networking/cluster/k9s/default.nix

···
     sha256 = "sha256-ws5JC2/WkgwxKwYtP9xtFELRhztzL6tNSvopyeC6H0Q=";
   };
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X github.com/derailed/k9s/cmd.version=${version}
-      -X github.com/derailed/k9s/cmd.commit=${src.rev}
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X github.com/derailed/k9s/cmd.version=${version}"
+    "-X github.com/derailed/k9s/cmd.commit=${src.rev}"
+  ];
 
   vendorSha256 = "sha256-T9khJeg5XPhVyUiu4gEEHZR6RgJF4P8LYFycqJglms8=";
 

pkgs/applications/networking/cluster/kpt/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/GoogleContainerTools/kpt/run.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/GoogleContainerTools/kpt/run.version=${version}" ];
 
   meta = with lib; {
     description = "A toolkit to help you manage, manipulate, customize, and apply Kubernetes Resource configuration data files";

pkgs/applications/networking/cluster/kubelogin/default.nix

···
 
   vendorSha256 = "sha256-vJfTf9gD/qrsPAfJeMYLjGa90mYLOshgDehv2Fcl6xM=";
 
-  buildFlagsArray = ''
-    -ldflags=
-        -X main.version=${version}
-        -X main.goVersion=${lib.getVersion go}
-  '';
+  ldflags = [
+    "-X main.version=${version}"
+    "-X main.goVersion=${lib.getVersion go}"
+  ];
 
   meta = with lib; {
     description = "A Kubernetes credential plugin implementing Azure authentication";

pkgs/applications/networking/cluster/kubeseal/default.nix

···
 
   subPackages = [ "cmd/kubeseal" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.VERSION=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.VERSION=${version}" ];
 
   meta = with lib; {
     description = "A Kubernetes controller and tool for one-way encrypted Secrets";

pkgs/applications/networking/cluster/kuttl/default.nix

···
 
   subPackages = [ "cmd/kubectl-kuttl" ];
 
-  buildFlagsArray = ''
-    -ldflags=-s -w
-    -X  github.com/kudobuilder/kuttl/pkg/version.gitVersion=${version}
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X github.com/kudobuilder/kuttl/pkg/version.gitVersion=${version}"
+  ];
 
   meta = with lib; {
     description = "The KUbernetes Test TooL (KUTTL) provides a declarative approach to testing production-grade Kubernetes operators";

pkgs/applications/networking/cluster/multus-cni/default.nix

···
     sha256 = "sha256-eVYRbMijOEa+DNCm4w/+WVrTI9607NF9/l5YKkXJuFs=";
   };
 
-  buildFlagsArray = let
+  ldflags = let
     multus = "gopkg.in/intel/multus-cni.v3/pkg/multus";
     commit = "f6298a3a294a79f9fbda0b8f175e521799d5f8d7";
   in [
-    "-ldflags=-s -w -X '${multus}.version=v${version}' -X '${multus}.commit=${commit}'"
+    "-s" "-w" "-X ${multus}.version=v${version}" "-X ${multus}.commit=${commit}"
   ];
 
   preInstall = ''

pkgs/applications/networking/cluster/popeye/default.nix

···
     sha256 = "sha256-oft1zLLd5TP8S9GMjp5kYaoPoOYnbhJwL2wBerkhp+c=";
   };
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X github.com/derailed/popeye/cmd.version=${version}
-      -X github.com/derailed/popeye/cmd.commit=${version}
+  ldflags = ''
+    "-s" "-w"
+    "-X github.com/derailed/popeye/cmd.version=${version}"
+    "-X github.com/derailed/popeye/cmd.commit=${version}"
   '';
 
   vendorSha256 = "sha256-vUUDLMicop5QzZmAHi5qrc0hx8oV2xWNFHvCWioLhl8=";

pkgs/applications/networking/cluster/qbec/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X github.com/splunk/qbec/internal/commands.version=${version}
-      -X github.com/splunk/qbec/internal/commands.commit=${src.rev}
-      -X github.com/splunk/qbec/internal/commands.goVersion=${lib.getVersion go}
+  ldflags = ''
+    "-s" "-w"
+    "-X github.com/splunk/qbec/internal/commands.version=${version}"
+    "-X github.com/splunk/qbec/internal/commands.commit=${src.rev}"
+    "-X github.com/splunk/qbec/internal/commands.goVersion=${lib.getVersion go}"
   '';
 
   meta = with lib; {

pkgs/applications/networking/cluster/sonobuoy/default.nix

···
   pname = "sonobuoy";
   version = "0.53.2"; # Do not forget to update `rev` above
 
-  buildFlagsArray =
+  ldflags =
     let t = "github.com/vmware-tanzu/sonobuoy";
-    in ''
-      -ldflags=
-        -s -X ${t}/pkg/buildinfo.Version=v${version}
-           -X ${t}/pkg/buildinfo.GitSHA=${rev}
-           -X ${t}/pkg/buildDate=unknown
-    '';
+    in [
+      "-s"
+      "-X ${t}/pkg/buildinfo.Version=v${version}"
+      "-X ${t}/pkg/buildinfo.GitSHA=${rev}"
+      "-X ${t}/pkg/buildDate=unknown"
+    ];
 
   src = fetchFromGitHub {
     sha256 = "sha256-8bUZsknG1Z2TKWwtuJtnauK8ibikGphl3oiLXT3PZzY=";

pkgs/applications/networking/cluster/stern/default.nix

···
 
   nativeBuildInputs = [ installShellFiles ];
 
-  buildFlagsArray =
-    [ "-ldflags=-s -w -X github.com/stern/stern/cmd.version=${version}" ];
+  ldflags =
+    [ "-s" "-w" "-X github.com/stern/stern/cmd.version=${version}" ];
 
   postInstall =
     let stern = if isCrossBuild then buildPackages.stern else "$out";

pkgs/applications/networking/cluster/tanka/default.nix

···
 
   subPackages = [ "cmd/tk" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -extldflags \"-static\" -X github.com/grafana/tanka/pkg/tanka.CURRENT_VERSION=v${version}" ];
+  ldflags = [ "-s" "-w" "-extldflags '-static'" "-X github.com/grafana/tanka/pkg/tanka.CURRENT_VERSION=v${version}" ];
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/applications/networking/cluster/tilt/default.nix

···
 
   subPackages = [ "cmd/tilt" ];
 
-  buildFlagsArray = [ "-ldflags=-X main.version=${version}" ];
+  ldflags = [ "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "Local development tool to manage your developer instance when your team deploys to Kubernetes in production";

pkgs/applications/networking/cluster/velero/default.nix

···
     sha256 = "sha256-oFDTjpcwlvSiAROG/EKYRCD+qKyZXu1gKotBcD0dfvk=";
   };
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X github.com/vmware-tanzu/velero/pkg/buildinfo.Version=${version}
-      -X github.com/vmware-tanzu/velero/pkg/buildinfo.GitSHA=${commit}
-      -X github.com/vmware-tanzu/velero/pkg/buildinfo.GitTreeState=clean
+  ldflags = ''
+    "-s" "-w"
+    "-X github.com/vmware-tanzu/velero/pkg/buildinfo.Version=${version}"
+    "-X github.com/vmware-tanzu/velero/pkg/buildinfo.GitSHA=${commit}"
+    "-X github.com/vmware-tanzu/velero/pkg/buildinfo.GitTreeState=clean"
   '';
 
   vendorSha256 = "sha256-ypgrdv6nVW+AAwyVsiROXs6jGgDTodGrGqiT2s5elOU=";

pkgs/applications/networking/dnscontrol/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-s -w" ];
+  ldflags = [ "-s" "-w" ];
 
   meta = with lib; {
     description = "Synchronize your DNS to multiple providers from a simple DSL";

pkgs/applications/networking/nextdns/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "NextDNS DNS/53 to DoH Proxy";

pkgs/applications/networking/shellhub-agent/default.nix

···
 
   vendorSha256 = "18z3vwcwkyj6hcvl35qmj034237h9l18dvcbx1hxry7qdwv807c9";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.AgentVersion=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.AgentVersion=v${version}" ];
 
   passthru = {
     updateScript = genericUpdater {

pkgs/applications/version-management/git-and-tools/ghorg/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "Quickly clone an entire org/users repositories into one directory";

pkgs/applications/version-management/git-and-tools/ghq/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X=main.Version=${version}
-  '';
+  ldflags = [
+    "-X=main.Version=${version}"
+  ];
 
   postInstall = ''
     install -m 444 -D ${src}/misc/zsh/_ghq $out/share/zsh/site-functions/_ghq

pkgs/applications/version-management/git-and-tools/git-bug/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X github.com/MichaelMure/git-bug/commands.GitCommit=${rev}
-      -X github.com/MichaelMure/git-bug/commands.GitLastTag=${version}
-      -X github.com/MichaelMure/git-bug/commands.GitExactTag=${version}
-  '';
+  ldflags = [
+    "-X github.com/MichaelMure/git-bug/commands.GitCommit=${rev}"
+    "-X github.com/MichaelMure/git-bug/commands.GitLastTag=${version}"
+    "-X github.com/MichaelMure/git-bug/commands.GitExactTag=${version}"
+  ];
 
   postInstall = ''
     install -D -m 0644 misc/bash_completion/git-bug "$out/share/bash-completion/completions/git-bug"

pkgs/applications/version-management/git-and-tools/git-chglog/default.nix

···
 
   vendorSha256 = "sha256-jIq+oacyT71m78iMZwWOBsBVAY/WxgyH9zRr8GiMGTU=";
 
-  buildFlagsArray = [ "-ldflags= -s -w -X=main.Version=v${version}" ];
+  ldflags = [ "-s" "-w" "-X=main.Version=v${version}" ];
 
   subPackages = [ "cmd/git-chglog" ];
 
···
     maintainers = with maintainers; [ ldenefle ];
   };
 }
-

pkgs/applications/version-management/git-and-tools/lab/default.nix

···
 
   nativeBuildInputs = [ makeWrapper installShellFiles ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   postInstall = ''
     wrapProgram $out/bin/lab --prefix PATH ":" "${lib.makeBinPath [ git xdg-utils ]}";

pkgs/applications/version-management/gitlab/gitlab-workhorse/default.nix

···
 
   vendorSha256 = "sha256-gTObI0pmRUX6Eh5FVdt+5LbckyBuFq1Ly4oPZztazHQ=";
   buildInputs = [ git ];
-  buildFlagsArray = "-ldflags=-X main.Version=${version}";
+  ldflags = [ "-X main.Version=${version}" ];
   doCheck = false;
 
   meta = with lib; {

pkgs/applications/video/go-chromecast/default.nix

···
 
   vendorSha256 = "sha256-idxElk4Sy7SE9G1OMRw8YH4o8orBa80qhBXPA+ar620=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version} -X main.commit=${src.rev} -X main.date=unknown" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" "-X main.commit=${src.rev}" "-X main.date=unknown" ];
 
   meta = with lib; {
     homepage = "https://github.com/vishen/go-chromecast";

pkgs/applications/virtualization/imgcrypt/default.nix

···
     sha256 = "177fs3p2xzwjsffcxqqllx6wi6ghfyqbvfgn95v3q7a2993yqk4k";
   };
 
-  buildFlagsArray = [
-    "-ldflags=-X github.com/containerd/containerd/version.Version=${version}"
+  ldflags = [
+    "-X github.com/containerd/containerd/version.Version=${version}"
   ];
 
   vendorSha256 = null;

pkgs/applications/virtualization/nvidia-container-toolkit/default.nix

···
   };
 
   vendorSha256 = "17zpiyvf22skfcisflsp6pn56y6a793jcx89kw976fq2x5br1bz7";
-  buildFlagsArray = [ "-ldflags=" "-s -w" ];
+  ldflags = [ "-s" "-w" ];
   nativeBuildInputs = [ makeWrapper ];
 
   postInstall = ''

pkgs/development/embedded/arduino/arduino-cli/default.nix

···
 
     doCheck = false;
 
-    buildFlagsArray = [
-      "-ldflags=-s -w -X github.com/arduino/arduino-cli/version.versionString=${version} -X github.com/arduino/arduino-cli/version.commit=unknown"
+    ldflags = [
+      "-s" "-w" "-X github.com/arduino/arduino-cli/version.versionString=${version}" "-X github.com/arduino/arduino-cli/version.commit=unknown"
     ] ++ lib.optionals stdenv.isLinux [ "-extldflags '-static'" ];
 
     meta = with lib; {

pkgs/development/tools/bazelisk/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.BazeliskVersion=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.BazeliskVersion=${version}" ];
 
   meta = with lib; {
     description = "A user-friendly launcher for Bazel";

pkgs/development/tools/build-managers/bazel/buildtools/default.nix

···
 
   excludedPackages = [ "generatetables" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.buildVersion=${version} -X main.buildScmRevision=${src.rev}" ];
+  ldflags = [ "-s" "-w" "-X main.buildVersion=${version}" "-X main.buildScmRevision=${src.rev}" ];
 
   meta = with lib; {
     description = "Tools for working with Google's bazel buildtool. Includes buildifier, buildozer, and unused_deps";

pkgs/development/tools/build-managers/mage/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-X github.com/magefile/mage/mage.commitHash=v${version}"
     "-X github.com/magefile/mage/mage.gitTag=v${version}"
     "-X github.com/magefile/mage/mage.timestamp=1970-01-01T00:00:00Z"

pkgs/development/tools/buildpack/default.nix

···
 
   subPackages = [ "cmd/pack" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/buildpacks/pack.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/buildpacks/pack.Version=${version}" ];
 
   postInstall = ''
     installShellCompletion --bash --name pack.bash $(PACK_HOME=$PWD $out/bin/pack completion --shell bash)

pkgs/development/tools/butane/default.nix

···
 
   subPackages = [ "internal" ];
 
-  buildFlagsArray = ''
-    -ldflags=-X github.com/coreos/butane/internal/version.Raw=v${version}
-  '';
+  ldflags = [
+    "-X github.com/coreos/butane/internal/version.Raw=v${version}"
+  ];
 
   postInstall = ''
     mv $out/bin/{internal,butane}

pkgs/development/tools/cloud-nuke/default.nix

···
 
   vendorSha256 = "sha256-C9UGpm8JBLQpSFQkvib5Bmn3J88LxUNt4ELJXL4ZQ80=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.VERSION=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.VERSION=${version}" ];
 
   doCheck = false;
 

pkgs/development/tools/conftest/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X github.com/open-policy-agent/conftest/internal/commands.version=${version}"

pkgs/development/tools/continuous-integration/buildkite-cli/default.nix

···
 
   subPackages = [ "cmd/bk" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.VERSION=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.VERSION=${version}" ];
 
   meta = with lib; {
     description = "A command line interface for Buildkite";

pkgs/development/tools/continuous-integration/fly/default.nix

···
 
   subPackages = [ "fly" ];
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X github.com/concourse/concourse.Version=${version}
-  '';
+  ldflags = [
+    "-X github.com/concourse/concourse.Version=${version}"
+  ];
 
   postInstall = lib.optionalString (stdenv.hostPlatform == stdenv.buildPlatform) ''
     mkdir -p $out/share/{bash-completion/completions,zsh/site-functions}

pkgs/development/tools/cue/default.nix

···
 
   subPackages = [ "cmd/cue" ];
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X cuelang.org/go/cmd/cue/cmd.version=${version}"
+  ldflags = [
+    "-s" "-w" "-X cuelang.org/go/cmd/cue/cmd.version=${version}"
   ];
 
   meta = {

pkgs/development/tools/dive/default.nix

···
 
   buildInputs = lib.optionals stdenv.isLinux [ btrfs-progs gpgme lvm2 ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "A tool for exploring each layer in a docker image";

pkgs/development/tools/earthly/default.nix

···
 
   vendorSha256 = "sha256-gydhh/EMSuE/beo+A2CRDdDnQGT6DMjMwthylT339I4=";
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X main.Version=v${version}
-      -X main.DefaultBuildkitdImage=earthly/buildkitd:v${version}
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X main.Version=v${version}"
+    "-X main.DefaultBuildkitdImage=earthly/buildkitd:v${version}"
+  ];
 
   BUILDTAGS = "dfrunmount dfrunsecurity dfsecrets dfssh dfrunnetwork";
   preBuild = ''

pkgs/development/tools/fission/default.nix

···
 
   vendorSha256 = "sha256-1ujJuhK7pm/A1Dd+Wm9dtc65mx9pwLBWMWwEJnbja8s=";
 
-  buildFlagsArray = "-ldflags=-s -w -X info.Version=${version}";
+  ldflags = [ "-s" "-w" "-X info.Version=${version}" ];
 
   subPackages = [ "cmd/fission-cli" ];
 

pkgs/development/tools/github/bump/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags=-X main.buildVersion=${version} -X main.buildCommit=${version} -X main.buildDate=1970-01-01"
+  ldflags = [
+    "-X main.buildVersion=${version}" "-X main.buildCommit=${version}" "-X main.buildDate=1970-01-01"
   ];
 
   meta = with lib; {
···
     maintainers = with maintainers; [ doronbehar ];
   };
 }
-

pkgs/development/tools/go-minimock/default.nix

···
     sha256 = "sha256-l+ngvmTb9yVgQYT+OeaVd0zz/xNZeXWrjMpVkMpbQIw=";
   };
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.version=${version}"
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}"
   ];
 
   vendorSha256 = "sha256-hn222ifKRYbASAHBJyMTCDwhykf2Jg9IqIUlK/GabJA=";

pkgs/development/tools/go-swagger/default.nix

···
 
   subPackages = [ "cmd/swagger" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/go-swagger/go-swagger/cmd/swagger/commands.Version=${version} -X github.com/go-swagger/go-swagger/cmd/swagger/commands.Commit=${src.rev}" ];
+  ldflags = [ "-s" "-w" "-X github.com/go-swagger/go-swagger/cmd/swagger/commands.Version=${version}" "-X github.com/go-swagger/go-swagger/cmd/swagger/commands.Commit=${src.rev}" ];
 
   meta = with lib; {
     description = "Golang implementation of Swagger 2.0, representation of your RESTful API";

pkgs/development/tools/go-task/default.nix

···
 
   subPackages = [ "cmd/task" ];
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.version=${version}"
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}"
   ];
 
   postInstall = ''

pkgs/development/tools/gomplate/default.nix

···
     rm net/net_test.go
   '';
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X github.com/${owner}/${pname}/v3/version.Version=${rev}"

pkgs/development/tools/gosec/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version} -X main.GitTag=${src.rev} -X main.BuildDate=unknown" ];
+  ldflags = [ "-s" "-w" "-X main.Version=${version}" "-X main.GitTag=${src.rev}" "-X main.BuildDate=unknown" ];
 
   meta = with lib; {
     homepage = "https://github.com/securego/gosec";
···
     platforms = platforms.linux ++ platforms.darwin;
   };
 }
-

pkgs/development/tools/gotestsum/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   subPackages = [ "." ];
 

pkgs/development/tools/hcloud/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/hetznercloud/cli/cli.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/hetznercloud/cli/cli.Version=${version}" ];
 
   postInstall = ''
     for shell in bash zsh; do

pkgs/development/tools/jsonnet-bundler/default.nix

···
 
   subPackages = [ "cmd/jb" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.Version=${version}" ];
 
   meta = with lib; {
     description = "A jsonnet package manager";

pkgs/development/tools/kubepug/default.nix

···
 
   vendorSha256 = "0jzry4znq4kcl6i9jcawilyjm8av1zxbml6nlr96v8x47ijxav5j";
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X=github.com/rikatz/kubepug/version.Version=${src.rev}
-  '';
+  ldflags = [
+    "-s" "-w" "-X=github.com/rikatz/kubepug/version.Version=${src.rev}"
+  ];
 
   subPackages = [ "cmd/kubepug.go" ];
 

pkgs/development/tools/kustomize/default.nix

···
   # rev is the commit of the tag, mainly for kustomize version command output
   rev = "9e8e7a7fe99ec9fbf801463e8607928322fc5245";
 
-  buildFlagsArray = let t = "sigs.k8s.io/kustomize/api/provenance"; in
-    ''
-      -ldflags=
-        -s -X ${t}.version=${version}
-           -X ${t}.gitCommit=${rev}
-    '';
+  ldflags = let t = "sigs.k8s.io/kustomize/api/provenance"; in
+    [
+      "-s"
+      "-X ${t}.version=${version}"
+      "-X ${t}.gitCommit=${rev}"
+    ];
 
   src = fetchFromGitHub {
     owner = "kubernetes-sigs";

pkgs/development/tools/lazygit/default.nix

···
   vendorSha256 = null;
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-X main.version=${version} -X main.buildSource=nix" ];
+  ldflags = [ "-X main.version=${version}" "-X main.buildSource=nix" ];
 
   meta = with lib; {
     description = "Simple terminal UI for git commands";

pkgs/development/tools/misc/circleci-cli/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/CircleCI-Public/circleci-cli/version.Version=${version} -X github.com/CircleCI-Public/circleci-cli/version.Commit=${src.rev} -X github.com/CircleCI-Public/circleci-cli/version.packageManager=nix" ];
+  ldflags = [ "-s" "-w" "-X github.com/CircleCI-Public/circleci-cli/version.Version=${version}" "-X github.com/CircleCI-Public/circleci-cli/version.Commit=${src.rev}" "-X github.com/CircleCI-Public/circleci-cli/version.packageManager=nix" ];
 
   preBuild = ''
     substituteInPlace data/data.go \

pkgs/development/tools/misc/k2tf/default.nix

···
 
   vendorSha256 = "1c2mwhrj0xapc661z1nb6am4qq3rd1pvbvjaxikjyx95n0gs8gjk";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version} -X main.commit=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" "-X main.commit=v${version}" ];
 
   meta = with lib; {
     description = "Kubernetes YAML to Terraform HCL converter";

pkgs/development/tools/misc/mkcert/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X main.Version=v${version}
-  '';
+  ldflags = [
+    "-s" "-w" "-X main.Version=v${version}"
+  ];
 
   meta = with lib; {
     homepage = "https://github.com/FiloSottile/mkcert";

pkgs/development/tools/misc/reviewdog/default.nix

···
 
   subPackages = [ "cmd/reviewdog" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/reviewdog/reviewdog/commands.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/reviewdog/reviewdog/commands.Version=${version}" ];
 
   meta = with lib; {
     description = "Automated code review tool integrated with any code analysis tools regardless of programming language";

pkgs/development/tools/misc/terracognita/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/cycloidio/terracognita/cmd.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/cycloidio/terracognita/cmd.Version=${version}" ];
 
   meta = with lib; {
     description = "Reads from existing Cloud Providers (reverse Terraform) and generates your infrastructure as code on Terraform configuration";

pkgs/development/tools/renderizer/default.nix

···
     sha256 = "sha256-jl98LuEsGN40L9IfybJhLnbzoYP/XpwFVQnjrlmDL9A=";
   };
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.version=${version} -X main.commitHash=${src.rev} -X main.date=19700101T000000"
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}" "-X main.commitHash=${src.rev}" "-X main.date=19700101T000000"
   ];
 
   vendorSha256 = null;

pkgs/development/tools/skaffold/default.nix

···
 
   subPackages = ["cmd/skaffold"];
 
-  buildFlagsArray = let t = "github.com/GoogleContainerTools/skaffold/pkg/skaffold"; in  ''
-    -ldflags=
-      -s -w
-      -X ${t}/version.version=v${version}
-      -X ${t}/version.gitCommit=${src.rev}
-      -X ${t}/version.buildDate=unknown
-  '';
+  ldflags = let t = "github.com/GoogleContainerTools/skaffold/pkg/skaffold"; in [
+    "-s" "-w"
+    "-X ${t}/version.version=v${version}"
+    "-X ${t}/version.gitCommit=${src.rev}"
+    "-X ${t}/version.buildDate=unknown"
+  ];
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/development/tools/tf2pulumi/default.nix

···
 
   vendorSha256 = "sha256-wsgNrDnFXbpanEULEjf6OxOeMYmWzjE7vpVUB/UFNp8=";
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X=github.com/pulumi/tf2pulumi/version.Version=${src.rev}
-  '';
+  ldflags = [
+    "-s" "-w" "-X=github.com/pulumi/tf2pulumi/version.Version=${src.rev}"
+  ];
 
   subPackages = [ "." ];
 

pkgs/development/tools/yj/default.nix

···
 
   vendorSha256 = "0y0n9fsb85qlpf9slwsxzarmfi98asa4x04qp2r8pagl28l0i8wv";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.Version=${version}" ];
 
   meta = with lib; {
     description = "Convert YAML <=> TOML <=> JSON <=> HCL";

pkgs/development/web/flyctl/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/superfly/flyctl/flyctl.Version=${version} -X github.com/superfly/flyctl/flyctl.Commit=${src.rev} -X github.com/superfly/flyctl/flyctl.BuildDate=1970-01-01T00:00:00+0000 -X github.com/superfly/flyctl/flyctl.Environment=production" ];
+  ldflags = [ "-s" "-w" "-X github.com/superfly/flyctl/flyctl.Version=${version}" "-X github.com/superfly/flyctl/flyctl.Commit=${src.rev}" "-X github.com/superfly/flyctl/flyctl.BuildDate=1970-01-01T00:00:00+0000" "-X github.com/superfly/flyctl/flyctl.Environment=production" ];
 
   meta = with lib; {
     description = "Command line tools for fly.io services";

pkgs/development/web/minify/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.Version=${version}" ];
 
   meta = with lib; {
     description = "Minifiers for web formats";

pkgs/os-specific/darwin/smimesign/default.nix

···
 
   vendorSha256 = "1cldxykm9qj5rvyfafam45y5xj4f19700s2f9w7ndhxgfp9vahvz";
 
-  buildFlagsArray = "-ldflags=-X main.versionString=v${version}";
+  ldflags = [ "-X main.versionString=v${version}" ];
 
   meta = with lib; {
     description = "An S/MIME signing utility for macOS and Windows that is compatible with Git";

pkgs/servers/blockbook/default.nix

···
 
   buildInputs = [ bzip2 lz4 rocksdb snappy zeromq zlib ];
 
-  buildFlagsArray = ''
-    -ldflags=
-       -X github.com/trezor/blockbook/common.version=${version}
-       -X github.com/trezor/blockbook/common.gitcommit=${commit}
-       -X github.com/trezor/blockbook/common.buildDate=unknown
-  '';
+  ldflags = [
+    "-X github.com/trezor/blockbook/common.version=${version}"
+    "-X github.com/trezor/blockbook/common.gitcommit=${commit}"
+    "-X github.com/trezor/blockbook/common.buildDate=unknown"
+  ];
 
   preBuild = lib.optionalString stdenv.isDarwin ''
     ulimit -n 8192

pkgs/servers/dex/default.nix

···
     "cmd/dex"
   ];
 
-  buildFlagsArray = [
-    "-ldflags=-w -s -X github.com/dexidp/dex/version.Version=${src.rev}"
+  ldflags = [
+    "-w" "-s" "-X github.com/dexidp/dex/version.Version=${src.rev}"
   ];
 
   postInstall = ''

pkgs/servers/hasura/cli.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [''-ldflags=
-    -X github.com/hasura/graphql-engine/cli/version.BuildVersion=${version}
-    -s
-    -w
-  ''];
+  ldflags = [
+    "-X github.com/hasura/graphql-engine/cli/version.BuildVersion=${version}"
+    "-s"
+    "-w"
+  ];
 
   postInstall = ''
     mkdir -p $out/share/{bash-completion/completions,zsh/site-functions}

pkgs/servers/http/pomerium/default.nix

···
     "cmd/pomerium-cli"
   ];
 
-  buildFlagsArray = let
+  ldflags = let
     # Set a variety of useful meta variables for stamping the build with.
     setVars = {
       Version = "v${version}";
···
     };
     varFlags = concatStringsSep " " (mapAttrsToList (name: value: "-X github.com/pomerium/pomerium/internal/version.${name}=${value}") setVars);
   in [
-    "-ldflags=${varFlags}"
+    "${varFlags}"
   ];
 
   nativeBuildInputs = [

pkgs/servers/maddy/default.nix

···
 
   vendorSha256 = "sha256-bxKEQaOubjRfLX+dMxVDzLOUInHykUdy9X8wvFE6Va4=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/foxcpp/maddy.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/foxcpp/maddy.Version=${version}" ];
 
   subPackages = [ "cmd/maddy" "cmd/maddyctl" ];
 

pkgs/servers/matrix-corporal/default.nix

···
     sha256 = "sha256-u1ppwy+t2ewAH0/+R6e0Ja5A3PQG/lUy2b6kgcMVj8E=";
   };
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.GitCommit=${version} -X main.GitBranch=${version} -X main.GitState=nixpkgs -X main.GitSummary=${version} -X main.Version=${version}"
+  ldflags = [
+    "-s" "-w" "-X main.GitCommit=${version}" "-X main.GitBranch=${version}" "-X main.GitState=nixpkgs" "-X main.GitSummary=${version}" "-X main.Version=${version}"
   ];
 
   vendorSha256 = "sha256-YmUiGsg2UZfV6SHEPwnbmWPhGQ5teV+we9MBaJyrJr4=";

pkgs/servers/miniflux/default.nix

···
     go test $(go list ./... | grep -v client)
   ''; # skip client tests as they require network access
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X miniflux.app/version.Version=${version}
-  '';
+  ldflags = [
+    "-s" "-w" "-X miniflux.app/version.Version=${version}"
+  ];
 
   postInstall = ''
     mv $out/bin/miniflux.app $out/bin/miniflux

pkgs/servers/misc/gobgpd/default.nix

···
     export CGO_ENABLED=0
   '';
 
-  buildFlagsArray = ''
-    -ldflags=
-    -s -w -extldflags '-static'
-  '';
+  ldflags = [
+    "-s" "-w" "-extldflags '-static'"
+  ];
 
   subPackages = [ "cmd/gobgpd" ];
 

pkgs/servers/monitoring/alertmanager-irc-relay/default.nix

···
 
   vendorSha256 = "sha256-VLG15IXS/fXFMTCJKEqGW6qZ9aOLPhazidVsOywG+w4=";
 
-  buildFlagsArray = [ "-ldflags=-s -w" ];
+  ldflags = [ "-s" "-w" ];
 
   meta = with lib; {
     description = "Alertmanager IRC Relay is a bot relaying Prometheus alerts to IRC";

pkgs/servers/monitoring/cadvisor/default.nix

···
 
   vendorSha256 = "sha256-FMO+wNmjFFD9+/9mhNcyZftk8ryhwFXDZeEy/h5EMWc=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/google/cadvisor/version.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/google/cadvisor/version.Version=${version}" ];
 
   postInstall = ''
     mv $out/bin/{cmd,cadvisor}

pkgs/servers/monitoring/do-agent/default.nix

···
     sha256 = "sha256-boEgCC3uWvJvb6VKpNhh6vHCfeE7oun5oneI2ITKh9g=";
   };
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X main.version=${version}
-  '';
+  ldflags = [
+    "-X main.version=${version}"
+  ];
 
   vendorSha256 = null;
 

pkgs/servers/monitoring/grafana/default.nix

···
     rm -r scripts/go
   '';
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X main.version=${version}
-  '';
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}"
+  ];
 
   postInstall = ''
     tar -xvf $srcStatic

pkgs/servers/monitoring/mackerel-agent/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = ''
-    -ldflags=
-    -X=main.version=${version}
-    -X=main.gitcommit=v${version}
-  '';
+  ldflags = [
+    "-X=main.version=${version}"
+    "-X=main.gitcommit=v${version}"
+  ];
 
   postInstall = ''
     wrapProgram $out/bin/mackerel-agent \

pkgs/servers/monitoring/mtail/default.nix

···
     go generate -x ./internal/vm/
   '';
 
-  buildFlagsArray = [
-    "-ldflags=-X main.Version=${version}"
+  ldflags = [
+    "-X main.Version=${version}"
   ];
 
   meta = with lib; {

pkgs/servers/monitoring/prometheus/artifactory-exporter.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = ''
-     -ldflags=
-      -s -w
-      -X github.com/prometheus/common/version.Version=${version}
-      -X github.com/prometheus/common/version.Revision=${rev}
-      -X github.com/prometheus/common/version.Branch=master
-      -X github.com/prometheus/common/version.BuildDate=19700101-00:00:00
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X github.com/prometheus/common/version.Version=${version}"
+    "-X github.com/prometheus/common/version.Revision=${rev}"
+    "-X github.com/prometheus/common/version.Branch=master"
+    "-X github.com/prometheus/common/version.BuildDate=19700101-00:00:00"
+  ];
 
   passthru.tests = { inherit (nixosTests.prometheus-exporters) artifactory; };
 

pkgs/servers/monitoring/prometheus/mysqld-exporter.nix

···
 
   vendorSha256 = "19785rfzlx8h0h8vmg0ghd40h3p4y6ikhgf8rd2qfj5f6qxfhrgv";
 
-  buildFlagsArray = let t = "github.com/prometheus/common/version"; in ''
-    -ldflags=
-        -s -w -X ${t}.Version=${version}
-        -X ${t}.Revision=${rev}
-        -X ${t}.Branch=unknown
-        -X ${t}.BuildUser=nix@nixpkgs
-        -X ${t}.BuildDate=unknown
-  '';
+  ldflags = let t = "github.com/prometheus/common/version"; in [
+    "-s" "-w"
+    "-X ${t}.Version=${version}"
+    "-X ${t}.Revision=${rev}"
+    "-X ${t}.Branch=unknown"
+    "-X ${t}.BuildUser=nix@nixpkgs"
+    "-X ${t}.BuildDate=unknown"
+  ];
 
   # skips tests with external dependencies, e.g. on mysqld
   checkFlags = [ "-short" ];

pkgs/servers/monitoring/prometheus/promscale.nix

···
 
   vendorSha256 = "sha256-DFDTYT7UK1cYwGeCgeQcJmrCoqGPDzicusRPPUbH0Gs=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/timescale/promscale/pkg/version.Version=${version} -X github.com/timescale/promscale/pkg/version.CommitHash=${src.rev}" ];
+  ldflags = [ "-s" "-w" "-X github.com/timescale/promscale/pkg/version.Version=${version}" "-X github.com/timescale/promscale/pkg/version.CommitHash=${src.rev}" ];
 
   doCheck = false; # Requires access to a docker daemon
   doInstallCheck = true;

pkgs/servers/monitoring/prometheus/redis-exporter.nix

···
 
   vendorSha256 = "11237959ikd7l5glkhfz0g55mbld2hq985b5crwb9bnimaly5lga";
 
-  buildFlagsArray = ''
-    -ldflags=
-       -X main.BuildVersion=${version}
-       -X main.BuildCommitSha=unknown
-       -X main.BuildDate=unknown
+  ldflags = ''
+    "-X main.BuildVersion=${version}"
+    "-X main.BuildCommitSha=unknown"
+    "-X main.BuildDate=unknown"
   '';
 
   # needs a redis server

pkgs/servers/monitoring/prometheus/smokeping-prober.nix

···
   pname = "smokeping_prober";
   version = "${baseVersion}-g${commit}";
 
-  buildFlagsArray = let
+  ldflags = let
     setVars = {
       Version = baseVersion;
       Revision = commit;
···
     };
     varFlags = lib.concatStringsSep " " (lib.mapAttrsToList (name: value: "-X github.com/prometheus/common/version.${name}=${value}") setVars);
   in [
-    "-ldflags=${varFlags} -s -w"
+    "${varFlags}" "-s" "-w"
   ];
 
   src = fetchFromGitHub {

pkgs/servers/monitoring/sensu-go/default.nix

···
 
   doCheck = false;
 
-      buildFlagsArray = let
+      ldflags = let
         versionPkg = "github.com/sensu/sensu-go/version";
-      in ''
-        -ldflags=
-          -X ${versionPkg}.Version=${version}
-          -X ${versionPkg}.BuildSHA=${shortRev}
-      '';
+      in [
+        "-X ${versionPkg}.Version=${version}"
+        "-X ${versionPkg}.BuildSHA=${shortRev}"
+      ];
 
       meta = {
         homepage = "https://sensu.io";

pkgs/servers/monitoring/thanos/default.nix

···
 
   subPackages = "cmd/thanos";
 
-  buildFlagsArray = let t = "github.com/prometheus/common/version"; in ''
-    -ldflags=
-       -X ${t}.Version=${version}
-       -X ${t}.Revision=unknown
-       -X ${t}.Branch=unknown
-       -X ${t}.BuildUser=nix@nixpkgs
-       -X ${t}.BuildDate=unknown
-  '';
+  ldflags = let t = "github.com/prometheus/common/version"; in [
+    "-X ${t}.Version=${version}"
+    "-X ${t}.Revision=unknown"
+    "-X ${t}.Branch=unknown"
+    "-X ${t}.BuildUser=nix@nixpkgs"
+    "-X ${t}.BuildDate=unknown"
+  ];
 
   meta = with lib; {
     description = "Highly available Prometheus setup with long term storage capabilities";

pkgs/servers/monitoring/unifi-poller/default.nix

···
 
   vendorSha256 = "sha256-LOBkdyfsw7ua6TsLglO5jdR9NWo5Df8rnQ8MH+eIz4g=";
 
-  buildFlagsArray = ''
-    -ldflags=-w -s
-      -X github.com/prometheus/common/version.Branch=master
-      -X github.com/prometheus/common/version.BuildDate=unknown
-      -X github.com/prometheus/common/version.Revision=${src.rev}
-      -X github.com/prometheus/common/version.Version=${version}-0
-  '';
+  ldflags = [
+    "-w" "-s"
+    "-X github.com/prometheus/common/version.Branch=master"
+    "-X github.com/prometheus/common/version.BuildDate=unknown"
+    "-X github.com/prometheus/common/version.Revision=${src.rev}"
+    "-X github.com/prometheus/common/version.Version=${version}-0"
+  ];
 
   meta = with lib; {
     description = "Collect ALL UniFi Controller, Site, Device & Client Data - Export to InfluxDB or Prometheus";

pkgs/servers/nosql/influxdb/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   excludedPackages = "test";
 

pkgs/servers/nosql/victoriametrics/default.nix

···
 
   vendorSha256 = null;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo.Version=${version}" ];
 
   passthru.tests = { inherit (nixosTests) victoriametrics; };
 

pkgs/servers/oauth2-proxy/default.nix

···
   vendorSha256 = "sha256-kclpoZ33JOciP2IUCQZB5idA7rgbWxPPFNwZU+pEJFU=";
 
   # Taken from https://github.com/oauth2-proxy/oauth2-proxy/blob/master/Makefile
-  buildFlagsArray = ("-ldflags=-X main.VERSION=${version}");
+  ldflags = [ "-X main.VERSION=${version}" ];
 
   meta = with lib; {
     description = "A reverse proxy that provides authentication with Google, Github, or other providers";

pkgs/servers/pg_featureserv/default.nix

···
 
   vendorSha256 = "1jqrkx850ghmpnfjhqky93r8fq7q63m5ivs0lzljzbvn7ya75f2r";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/CrunchyData/pg_featureserv/conf.setVersion=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/CrunchyData/pg_featureserv/conf.setVersion=${version}" ];
 
   meta = with lib; {
     description = "Lightweight RESTful Geospatial Feature Server for PostGIS in Go";

pkgs/servers/pg_tileserv/default.nix

···
 
   vendorSha256 = "sha256-qdlh9H039GwKTxOhx+dzyUHkzJbaOeuguKnBOyAPe/E=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.programVersion=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.programVersion=${version}" ];
 
   doCheck = false;
 

pkgs/servers/reproxy/default.nix

···
 
   vendorSha256 = null;
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.revision=${version}"
+  ldflags = [
+    "-s" "-w" "-X main.revision=${version}"
   ];
 
   installPhase = ''

pkgs/servers/rtsp-simple-server/default.nix

···
   # Tests need docker
   doCheck = false;
 
-  buildFlagsArray = [
-    # In the future, we might need to switch to `main.Version`, considering:
-    # https://github.com/aler9/rtsp-simple-server/issues/503
-    "-ldflags=-X github.com/aler9/rtsp-simple-server/internal/core.version=v${version}"
+  # In the future, we might need to switch to `main.Version`, considering:
+  # https://github.com/aler9/rtsp-simple-server/issues/503
+  ldflags = [
+    "-X github.com/aler9/rtsp-simple-server/internal/core.version=v${version}"
   ];
 
   meta = with lib; {

pkgs/shells/elvish/default.nix

···
 
   excludedPackages = [ "website" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/elves/elvish/pkg/buildinfo.Version==${version} -X github.com/elves/elvish/pkg/buildinfo.Reproducible=true" ];
+  ldflags = [ "-s" "-w" "-X github.com/elves/elvish/pkg/buildinfo.Version==${version}" "-X github.com/elves/elvish/pkg/buildinfo.Reproducible=true" ];
 
   src = fetchFromGitHub {
     owner = "elves";

pkgs/shells/zsh/antibody/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "The fastest shell plugin manager";

pkgs/tools/admin/aws-vault/default.nix

···
   subPackages = [ "." ];
 
   # set the version. see: aws-vault's Makefile
-  buildFlagsArray = ''
-    -ldflags=
-    -X main.Version=v${version}
-  '';
+  ldflags = [
+    "-X main.Version=v${version}"
+  ];
 
   doInstallCheck = true;
 

pkgs/tools/admin/awsweeper/default.nix

···
 
   vendorSha256 = "sha256-1u1mzANLlWduAQF1GUX7BJSyYlSZwNQISqKwbyRlGog=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/jckuester/awsweeper/internal.version=${version} -X github.com/jckuester/awsweeper/internal.commit=${src.rev} -X github.com/jckuester/awsweeper/internal.date=unknown" ];
+  ldflags = [ "-s" "-w" "-X github.com/jckuester/awsweeper/internal.version=${version}" "-X github.com/jckuester/awsweeper/internal.commit=${src.rev}" "-X github.com/jckuester/awsweeper/internal.date=unknown" ];
 
   doCheck = false;
 

pkgs/tools/admin/chamber/default.nix

···
 
   vendorSha256 = "sha256-XpLLolxWu9aMp1cyG4dUQk4YtknbIRMmBUdSeyY4PNk=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.Version=v${version}" ];
 
   meta = with lib; {
     description =

pkgs/tools/admin/credhub-cli/default.nix

···
 
   vendorSha256 = null;
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X code.cloudfoundry.org/credhub-cli/version.Version=${version}"

pkgs/tools/admin/fioctl/default.nix

···
 
   runVend = true;
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X github.com/foundriesio/fioctl/subcommands/version.Commit=${src.rev}
-  '';
+  ldflags = [
+    "-s" "-w" "-X github.com/foundriesio/fioctl/subcommands/version.Commit=${src.rev}"
+  ];
 
   meta = with lib; {
     description = "A simple CLI to manage your Foundries Factory ";

pkgs/tools/admin/iamy/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [''-ldflags=
-    -X main.Version=v${version} -s -w
-  ''];
+  ldflags = [
+    "-X main.Version=v${version}" "-s" "-w"
+  ];
 
   meta = with lib; {
     description = "A cli tool for importing and exporting AWS IAM configuration to YAML files";

pkgs/tools/admin/lego/default.nix

···
 
   subPackages = [ "cmd/lego" ];
 
-  buildFlagsArray = [
-    "-ldflags=-X main.version=${version}"
+  ldflags = [
+    "-X main.version=${version}"
   ];
 
   meta = with lib; {

pkgs/tools/admin/ssmsh/default.nix

···
 
   doCheck = true;
 
-  buildFlagsArray = [ "-ldflags=-w -s -X main.Version=${version}" ];
+  ldflags = [ "-w" "-s" "-X main.Version=${version}" ];
 
   meta = with lib; {
     homepage = "https://github.com/bwhaley/ssmsh";

pkgs/tools/backup/kopia/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = ''
-    -ldflags=
-       -X github.com/kopia/kopia/repo.BuildVersion=${version}
-       -X github.com/kopia/kopia/repo.BuildInfo=${src.rev}
-  '';
+  ldflags = [
+    "-X github.com/kopia/kopia/repo.BuildVersion=${version}"
+    "-X github.com/kopia/kopia/repo.BuildInfo=${src.rev}"
+  ];
 
   meta = with lib; {
     homepage = "https://kopia.io";

pkgs/tools/filesystems/gocryptfs/default.nix

···
 
   propagatedBuildInputs = [ libfido2 ];
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X main.GitVersion=${version}
-      -X main.GitVersionFuse=[vendored]
-      -X main.BuildDate=unknown
-  '';
+  ldflags = [
+    "-X main.GitVersion=${version}"
+    "-X main.GitVersionFuse=[vendored]"
+    "-X main.BuildDate=unknown"
+  ];
 
   subPackages = [ "." "gocryptfs-xray" "contrib/statfs" ];
 

pkgs/tools/misc/chezmoi/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.version=${version} -X main.builtBy=nixpkgs"
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}" "-X main.builtBy=nixpkgs"
   ];
 
   nativeBuildInputs = [ installShellFiles ];

pkgs/tools/misc/duf/default.nix

···
 
   vendorSha256 = "153z0ccd556c0wpnxgyjq7m0c4y2z6fxsqq2p77kly9nr8cpzdb9";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X=main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X=main.Version=${version}" ];
 
   meta = with lib; {
     homepage = "https://github.com/muesli/duf/";

pkgs/tools/misc/goreleaser/default.nix

···
 
   vendorSha256 = "sha256-7I/955dPHV8Rkp6VevkebkZaNtSlbzIsGc8qFjtcMXk=";
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X main.version=${version}"

pkgs/tools/misc/gotify-cli/default.nix

···
     mv $out/bin/cli $out/bin/gotify
   '';
 
-  buildFlagsArray = [
-    "-ldflags=-X main.Version=${version} -X main.Commit=${version} -X main.BuildDate=1970-01-01"
+  ldflags = [
+    "-X main.Version=${version}" "-X main.Commit=${version}" "-X main.BuildDate=1970-01-01"
   ];
 
   meta = with lib; {

pkgs/tools/misc/lf/default.nix

···
 
   nativeBuildInputs = [ installShellFiles ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.gVersion=r${version}" ];
+  ldflags = [ "-s" "-w" "-X main.gVersion=r${version}" ];
 
   postInstall = ''
     install -D --mode=444 lf.desktop $out/share/applications/lf.desktop

pkgs/tools/misc/microplane/default.nix

···
 
   vendorSha256 = "sha256-PqSjSFTVrIsQ065blIxZ9H/ARku6BEcnjboH+0K0G14=";
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X main.version=${version}
-  '';
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}"
+  ];
 
   postInstall = ''
     ln -s $out/bin/microplane $out/bin/mp

pkgs/tools/misc/pgcenter/default.nix

···
 
   subPackages = [ "cmd" ];
 
-  buildFlagsArray = [ "-ldflags=-w -s -X main.gitTag=${src.rev} -X main.gitCommit=${src.rev} -X main.gitBranch=master" ];
+  ldflags = [ "-w" "-s" "-X main.gitTag=${src.rev}" "-X main.gitCommit=${src.rev}" "-X main.gitBranch=master" ];
 
   postInstall = ''
     mv $out/bin/cmd $out/bin/pgcenter

pkgs/tools/misc/pgmetrics/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     homepage = "https://pgmetrics.io/";

pkgs/tools/misc/pistol/default.nix

···
     installManPage pistol.1
   '';
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.Version=${version}" ];
 
   meta = with lib; {
     description = "General purpose file previewer designed for Ranger, Lf to make scope.sh redundant";

pkgs/tools/misc/tfk8s/default.nix

···
   vendorSha256 = "sha256-eLPmghs05pMMtys97Ja7YGdVMZmMmiaFeMwzaWNxW0I=";
   runVend = true;
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X main.toolVersion=${tag}"

pkgs/tools/misc/vsh/default.nix

···
   vendorSha256 = null;
 
   # make sure version gets set at compile time
-  buildFlagsArray = [ "-ldflags=-s -w -X main.vshVersion=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.vshVersion=v${version}" ];
 
   meta = with lib; {
     description = "HashiCorp Vault interactive shell";

pkgs/tools/networking/cassowary/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     homepage = "https://github.com/rogerwelin/cassowary";

pkgs/tools/networking/chisel/default.nix

···
 
   vendorSha256 = "sha256-GzsQ6LXxe9UQc13XbsYFOWPe0EzlyHechchKc6xDkAc=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/jpillora/chisel/share.BuildVersion=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/jpillora/chisel/share.BuildVersion=${version}" ];
 
   # tests require access to the network
   doCheck = false;

pkgs/tools/networking/clash/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-X github.com/Dreamacro/clash/constant.Version=${version}"
   ];
 

pkgs/tools/networking/gobgp/default.nix

···
     export CGO_ENABLED=0
   '';
 
-  buildFlagsArray = ''
-    -ldflags=
-    -s -w -extldflags '-static'
-  '';
+  ldflags = [
+    "-s" "-w" "-extldflags '-static'"
+  ];
 
   subPackages = [ "cmd/gobgp" ];
 

pkgs/tools/networking/grpcui/default.nix

···
 
   subPackages = [ "cmd/grpcui" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "An interactive web UI for gRPC, along the lines of postman";

pkgs/tools/networking/grpcurl/default.nix

···
 
   vendorSha256 = "sha256-nl8vKVhUMSO20qCDyhNkU5cghNy8vIFqSBvLk59nbWg=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "Like cURL, but for gRPC: Command-line tool for interacting with gRPC servers";

pkgs/tools/networking/nebula/default.nix

···
 
   subPackages = [ "cmd/nebula" "cmd/nebula-cert" ];
 
-  buildFlagsArray = [ "-ldflags=" "-X main.Build=${version}" ];
+  ldflags = [ "-X main.Build=${version}" ];
 
   meta = with lib; {
     description = "A scalable overlay networking tool with a focus on performance, simplicity and security";

pkgs/tools/networking/shadowfox/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags=-X main.tag=v${version}"
+  ldflags = [
+    "-X main.tag=v${version}"
   ];
 
   meta = with lib; {

pkgs/tools/networking/telepresence2/default.nix

···
 
   vendorSha256 = "1snmp461h8driy1w1xggk669yxl0sjl1m9pbqm7dwk44yb94zi1q";
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X=github.com/telepresenceio/telepresence/v2/pkg/version.Version=${src.rev}
-  '';
+  ldflags = [
+    "-s" "-w" "-X=github.com/telepresenceio/telepresence/v2/pkg/version.Version=${src.rev}"
+  ];
 
   subPackages = [ "cmd/telepresence" ];
 

pkgs/tools/networking/termshark/default.nix

···
     wrapProgram $out/bin/termshark --prefix PATH : ${lib.makeBinPath [ wireshark-cli ]}
   '';
 
-  buildFlagsArray = ''
-    -ldflags=
-    -X github.com/gcla/termshark.Version=${version}
-  '';
+  ldflags = [
+    "-X github.com/gcla/termshark.Version=${version}"
+  ];
 
   meta = with lib; {
     homepage = "https://termshark.io/";

pkgs/tools/networking/yggdrasil/default.nix

···
 
   subPackages = [ "cmd/yggdrasil" "cmd/yggdrasilctl" ];
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X github.com/yggdrasil-network/yggdrasil-go/src/version.buildVersion=${version}
-      -X github.com/yggdrasil-network/yggdrasil-go/src/version.buildName=${pname}
-      -s -w
-  '';
+  ldflags = [
+    "-X github.com/yggdrasil-network/yggdrasil-go/src/version.buildVersion=${version}"
+    "-X github.com/yggdrasil-network/yggdrasil-go/src/version.buildName=${pname}"
+    "-s" "-w"
+  ];
 
   passthru.tests.basic = nixosTests.yggdrasil;
 

pkgs/tools/package-management/holo-build/default.nix

···
 
   subPackages = [ "src/holo-build" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/holocm/holo-build/src/holo-build/common.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/holocm/holo-build/src/holo-build/common.version=${version}" ];
 
   postBuild = ''
     make build/man/holo-build.8 VERSION=${version}

pkgs/tools/package-management/morph/default.nix

···
 
   nativeBuildInputs = [ makeWrapper go-bindata ];
 
-  buildFlagsArray = ''
-    -ldflags=
-    -X
-    main.version=${version}
-  '';
+  ldflags = [
+    "-X main.version=${version}"
+  ];
 
   postPatch = ''
     go-bindata -pkg assets -o assets/assets.go data/

pkgs/tools/package-management/nfpm/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "A simple deb and rpm packager written in Go";

pkgs/tools/security/aws-iam-authenticator/default.nix

···
   deleteVendor = true;
   vendorSha256 = "+Z8sENIMWXP29Piwb/W6i7UdNXVq6ZnO7AZbSaUYCME=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=v${version}" ];
 
   subPackages = [ "cmd/aws-iam-authenticator" ];
 

pkgs/tools/security/cfssl/default.nix

···
     popd
   '';
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X github.com/cloudflare/cfssl/cli/version.version=v${version}
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X github.com/cloudflare/cfssl/cli/version.version=v${version}"
+  ];
 
   meta = with lib; {
     homepage = "https://cfssl.org/";

pkgs/tools/security/doppler/default.nix

···
 
   vendorSha256 = "sha256-yb7L4GSKtlwagwdxBMd5aSk9fre1NKKsy6CM4Iv2ya8=";
 
-  buildFlagsArray = "-ldflags=-X github.com/DopplerHQ/cli/pkg/version.ProgramVersion=v${version}";
+  ldflags = [ "-X github.com/DopplerHQ/cli/pkg/version.ProgramVersion=v${version}" ];
 
   postInstall = ''
     mv $out/bin/cli $out/bin/doppler

pkgs/tools/security/gopass/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version} -X main.commit=${src.rev}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" "-X main.commit=${src.rev}" ];
 
   wrapperPath = lib.makeBinPath (
     [

pkgs/tools/security/gopass/git-credential.nix

···
 
   nativeBuildInputs = [ makeWrapper ];
 
-  preBuild = ''
-    buildFlagsArray+=(
-      "-ldflags=-s -w -X main.version=${version} -X main.commit=${src.rev}"
-    )
-  '';
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}" "-X main.commit=${src.rev}"
+  ];
 
   postFixup = ''
     wrapProgram $out/bin/git-credential-gopass --prefix PATH : "${lib.makeBinPath [ gopass ]}"

pkgs/tools/security/gopass/jsonapi.nix

···
 
   nativeBuildInputs = [ installShellFiles makeWrapper ];
 
-  preBuild = ''
-    buildFlagsArray+=(
-      "-ldflags=-s -w -X main.version=${version} -X main.commit=${src.rev}"
-    )
-  '';
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}" "-X main.commit=${src.rev}"
+  ];
 
   postFixup = ''
     wrapProgram $out/bin/gopass-jsonapi --prefix PATH : "${lib.makeBinPath [ gopass ]}"

pkgs/tools/security/saml2aws/default.nix

···
 
   subPackages = [ "." "cmd/saml2aws" ];
 
-  buildFlagsArray = ''
-    -ldflags=-X main.Version=${version}
-  '';
+  ldflags = [
+    "-X main.Version=${version}"
+  ];
 
   meta = with lib; {
     description = "CLI tool which enables you to login and retrieve AWS temporary credentials using a SAML IDP";

pkgs/tools/security/step-ca/default.nix

···
 
   vendorSha256 = "sha256-cFuLW0qkI/l/TvYwQZA2bLlWYjs1hdbQJ5jU7xiuFZI=";
 
-  buildFlagsArray = [ "-ldflags=-buildid=" ];
+  ldflags = [ "-buildid=" ];
 
   nativeBuildInputs = lib.optionals hsmSupport [ pkg-config ];
 

pkgs/tools/security/subjs/default.nix

···
 
   vendorSha256 = "1y01k8pvv7y9zb15wbk068cvkx0g83484jak2dvcvghqcf5j1fr1";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.AppVersion=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.AppVersion=${version}" ];
 
   meta = with lib; {
     description = "Fetcher for Javascript files";

pkgs/tools/system/ctop/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version} -X main.build=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" "-X main.build=v${version}" ];
 
   meta = with lib; {
     description = "Top-like interface for container metrics";

pkgs/tools/system/hostctl/default.nix

···
 
   vendorSha256 = "sha256-rGDWrivIdl5FTu/kNR8nAfE2+1hE4cm3uDg7oBobE9M=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/guumaster/hostctl/cmd/hostctl/actions.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/guumaster/hostctl/cmd/hostctl/actions.version=${version}" ];
 
   nativeBuildInputs = [ installShellFiles ];
   postInstall = ''
···
     maintainers = with maintainers; [ blaggacao ];
   };
 }
-

pkgs/tools/system/netdata/go.d.plugin.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   postInstall = ''
     mkdir -p $out/lib/netdata/conf.d

pkgs/tools/text/mark/default.nix

···
 
   vendorSha256 = "sha256-y3Q8UebNbLy1jmxUC37mv+2l8dCU3b/Fk8XHn5u57p0=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "A tool for syncing your markdown documentation with Atlassian Confluence pages";

pkgs/tools/text/vale/default.nix

···
     cp -r styles $data/share/vale
   '';
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     homepage = "https://docs.errata.ai/vale/about";

pkgs/tools/virtualization/shipyard/default.nix

···
   };
   vendorSha256 = "sha256-tTkPFftPDNXafIjAjNg6V6e/+2S/v5Do/YyAXPaGIqA=";
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.version=${version}"
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}"
   ];
 
   # Tests require a large variety of tools and resources to run including