xcbuild: rework to use lib.PLIST

This is a good way to test that plist works.

Sorry for the large diff. There are a bunch of cleanups in here that
needed to be done. Should make it possible to use in cross
compilation.

pkgs/development/tools/xcbuild/default.nix

···
-{ stdenv, cmake, fetchFromGitHub, zlib, libxml2, libpng, CoreServices, CoreGraphics, ImageIO, ninja }:
+{ stdenv, cmake, fetchFromGitHub, zlib, libxml2, libpng
+, CoreServices, CoreGraphics, ImageIO, ninja }:
 
 let
   googletest = fetchFromGitHub {
···
 in stdenv.mkDerivation rec {
   name    = "xcbuild-${version}";
 
-  # Once a version is released that includes https://github.com/facebook/xcbuild/commit/183c087a6484ceaae860c6f7300caf50aea0d710,
+  # Once a version is released that includes
+  # https://github.com/facebook/xcbuild/commit/183c087a6484ceaae860c6f7300caf50aea0d710,
   # we can stop doing this -pre thing.
   version = "0.1.2-pre";
 

pkgs/development/tools/xcbuild/platform.nix

···
-{ stdenv, sdk, writeText, platformName, xcbuild }:
+{ runCommand, lib, sdk, platformName, writeText }:
 
 let
+
+  inherit (lib.generators) toPLIST;
 
   Info = {
     CFBundleIdentifier = platformName;
···
 
 in
 
-stdenv.mkDerivation {
-  name = "MacOSX.platform";
-  buildInputs = [ xcbuild ];
-  buildCommand = ''
-    mkdir -p $out/
-    cd $out/
-
-    plutil -convert xml1 -o Info.plist ${writeText "Info.plist" (builtins.toJSON Info)}
-    plutil -convert xml1 -o version.plist ${writeText "version.plist" (builtins.toJSON Version)}
-
-    mkdir -p $out/Developer/Library/Xcode/Specifications/
-    cd $out/Developer/Library/Xcode/Specifications/
-    plutil -convert xml1 -o Architectures.xcspec ${writeText "Architectures.xcspec" (builtins.toJSON Architectures)}
-    plutil -convert xml1 -o PackageTypes.xcspec ${writeText "PackageTypes.xcspec" (builtins.toJSON PackageTypes)}
-    plutil -convert xml1 -o ProductTypes.xcspec ${writeText "ProductTypes.xcspec" (builtins.toJSON ProductTypes)}
+runCommand "MacOSX.platform" {} ''
+  install -D ${writeText "Info.plist" (toPLIST Info)} $out/Info.plist
+  install -D ${writeText "version.plist" (toPLIST Version)} $out/version.plist
+  install -D ${writeText "Architectures.xcspec" (toPLIST Architectures)} $out/Developer/Library/Xcode/Specifications/Architectures.xcspec
+  install -D ${writeText "PackageTypes.xcspec" (toPLIST PackageTypes)} $out/Developer/Library/Xcode/Specifications/PackageTypes.xcspec
+  install -D ${writeText "ProductTypes.xcspec" (toPLIST ProductTypes)} $out/Developer/Library/Xcode/Specifications/ProductTypes.xcspec
 
-    mkdir -p $out/Developer/SDKs/
-    cd $out/Developer/SDKs/
-    cp -r ${sdk} ${sdk.name}
-  '';
-}
+  mkdir -p $out/Developer/SDKs/
+  cd $out/Developer/SDKs/
+  cp -r ${sdk} ${sdk.name}
+''

pkgs/development/tools/xcbuild/sdk.nix

···
-{ stdenv, writeText, toolchainName, sdkName, xcbuild }:
+{ runCommand, lib, toolchainName, sdkName, writeText }:
 
 let
+  inherit (lib.generators) toPLIST;
+
   # TODO: expose MACOSX_DEPLOYMENT_TARGET in nix so we can use it here.
   version = "10.10";
 
···
   };
 in
 
-stdenv.mkDerivation {
-  name = "MacOSX${version}.sdk";
+runCommand "MacOSX${version}.sdk" {
   inherit version;
-
-  buildInputs = [ xcbuild ];
-
-  buildCommand = ''
-    mkdir -p $out/
-    plutil -convert xml1 -o $out/SDKSettings.plist ${writeText "SDKSettings.json" (builtins.toJSON SDKSettings)}
-
-    mkdir -p $out/System/Library/CoreServices/
-    plutil -convert xml1 -o $out/System/Library/CoreServices/SystemVersion.plist ${writeText "SystemVersion.plist" (builtins.toJSON SystemVersion)}
-  '';
-}
+} ''
+  install -D ${writeText "SDKSettings.plist" (toPLIST SDKSettings)} $out/SDKSettings.plist
+  install -D ${writeText "SystemVersion.plist" (toPLIST SystemVersion)} $out/System/Library/CoreServices/SystemVersion.plist
+''

pkgs/development/tools/xcbuild/toolchain.nix

···
-{stdenv, writeText, toolchainName, xcbuild, fetchurl
-, llvm, cctools, gcc, bootstrap_cmds, binutils
-, yacc, flex, m4, unifdef, gperf, indent, ctags, makeWrapper
-, xib2nib}:
+{ runCommand, toolchainName, fetchurl, makeWrapper, stdenv
+, buildPackages, lib, writeText }:
 
 let
+
+  inherit (lib) getBin optionalString;
+  inherit (lib.generators) toPLIST;
 
   ToolchainInfo = {
     Identifier = toolchainName;
   };
 
-  # We could pull this out of developer_cmds but it adds an annoying loop if we want to bootstrap and
-  # this is just a tiny script so I'm not going to bother
+  # We could pull this out of developer_cmds but it adds an annoying
+  # loop if we want to bootstrap and this is just a tiny script so I'm
+  # not going to bother.
   mkdep-darwin-src = fetchurl {
     url        = "https://opensource.apple.com/source/developer_cmds/developer_cmds-63/mkdep/mkdep.sh";
     sha256     = "0n4wpqfslfjs5zbys5yri8pfi2awyhlmknsf6laa5jzqbzq9x541";
···
   };
 in
 
-stdenv.mkDerivation {
-  name = "nixpkgs.xctoolchain";
-  buildInputs = [ xcbuild makeWrapper ];
-
-  ## cctools should build on Linux but it doesn't currently
-
-  buildCommand = ''
-    mkdir -p $out
-    plutil -convert xml1 -o $out/ToolchainInfo.plist ${writeText "ToolchainInfo.plist" (builtins.toJSON ToolchainInfo)}
-
-    mkdir -p $out/usr/include
-    mkdir -p $out/usr/lib
-    mkdir -p $out/usr/libexec
-    mkdir -p $out/usr/share
-
-    mkdir -p $out/usr/bin
-    cd $out/usr/bin
-    ln -s ${stdenv.cc}/bin/cpp
-    ln -s ${stdenv.cc}/bin/c++
-    ln -s ${stdenv.cc}/bin/cc
-    ln -s c++ clang++
-    ln -s cc clang
-
-    ln -s ${llvm}/bin/llvm-cov
-    ln -s ${llvm}/bin/llvm-dsymutil
-    ln -s ${llvm}/bin/llvm-dwarfdump
-    ln -s ${llvm}/bin/llvm-nm
-    ln -s ${llvm}/bin/llvm-objdump
-    ln -s ${llvm}/bin/llvm-otool
-    ln -s ${llvm}/bin/llvm-profdata
-    ln -s ${llvm}/bin/llvm-size
-
-    ln -s ${yacc}/bin/yacc
-    ln -s ${yacc}/bin/bison
-    ln -s ${flex}/bin/flex
-    ln -s ${flex}/bin/flex++
-
-    ln -s flex lex
-
-    ln -s ${m4}/bin/m4
-    ln -s m4 gm4
+runCommand "nixpkgs.xctoolchain" {
+  nativeBuildInputs = [ makeWrapper ];
+} (''
+  mkdir -p $out
+  install -D ${writeText "ToolchainInfo.plist" (toPLIST ToolchainInfo)} $out/ToolchainInfo.plist
 
-    ln -s ${unifdef}/bin/unifdef
-    ln -s ${unifdef}/bin/unifdefall
+  mkdir -p $out/usr/include
+  mkdir -p $out/usr/lib
+  mkdir -p $out/usr/libexec
+  mkdir -p $out/usr/share
+  mkdir -p $out/usr/bin
 
-    ln -s ${gperf}/bin/gperf
-    ln -s ${indent}/bin/indent
-    ln -s ${ctags}/bin/ctags
-  '' + stdenv.lib.optionalString stdenv.isDarwin ''
-    ln -s ${bootstrap_cmds}/bin/mig
-    ln -s ${binutils}/bin/lipo
+  for bin in ${getBin stdenv.cc}/bin/*; do
+    ln -s $bin $out/usr/bin
+  done
 
-    ln -s ${cctools}/bin/ar
-    ln -s ${cctools}/bin/as
-    ln -s ${cctools}/bin/nm
-    ln -s ${cctools}/bin/nmedit
-    ln -s ${cctools}/bin/ld
-    ln -s ${cctools}/bin/libtool
-    ln -s ${cctools}/bin/strings
-    ln -s ${cctools}/bin/strip
-    ln -s ${cctools}/bin/install_name_tool
-    ln -s ${cctools}/bin/bitcode_strip
-    ln -s ${cctools}/bin/codesign_allocate
-    ln -s ${cctools}/bin/dsymutil
-    ln -s ${cctools}/bin/dyldinfo
-    ln -s ${cctools}/bin/otool
-    ln -s ${cctools}/bin/unwinddump
-    ln -s ${cctools}/bin/size
-    ln -s ${cctools}/bin/segedit
-    ln -s ${cctools}/bin/pagestuff
-    ln -s ${cctools}/bin/ranlib
-    ln -s ${cctools}/bin/redo_prebinding
+  for bin in ${getBin stdenv.cc.bintools.bintools}/bin/*; do
+    if ! [ -e "$out/usr/bin/$(basename $bin)" ]; then
+      ln -s $bin $out/usr/bin
+    fi
+  done
 
-    ln -s ${xib2nib}/bin/ibtool
-  '' +
-    # No point including the entire gcc closure if we don't already have it
-    (if stdenv.cc.isClang then ''
-      ln -s ${stdenv.cc.cc.llvm}/bin/llvm-cov gcov
-      ln -s ${mkdep-darwin-src}               mkdep
-    '' else ''
-      ln -s ${gcc}/bin/gcov
-      ln -s ${gcc}/bin/mkdep
-    '');
-}
+  ln -s ${buildPackages.yacc}/bin/yacc $out/usr/bin/yacc
+  ln -s ${buildPackages.yacc}/bin/bison $out/usr/bin/bison
+  ln -s ${buildPackages.flex}/bin/flex $out/usr/bin/flex
+  ln -s ${buildPackages.flex}/bin/flex++ $out/usr/bin/flex++
+  ln -s $out/bin/flex $out/usr/bin/lex
 
-# other commands in /bin/
-#   asa
-#   cmpdylib (in cctools)
-#   ctf_insert (in cctools)
-#   dwarfdump
-#   lorder
-#   rebase
-#   rpcgen (in developer_cmds)
-#   what
+  ln -s ${buildPackages.m4}/bin/m4 $out/usr/bin/m4
+  ln -s $out/usr/bin/m4 $out/usr/bin/gm4
 
+  ln -s ${buildPackages.unifdef}/bin/unifdef $out/usr/bin/unifdef
+  ln -s ${buildPackages.unifdef}/bin/unifdefall $out/usr/bin/unifdefall
 
-# swift: see #11463
-#   swift
-#   swift-compress
-#   swift-demangle
-#   swift-stdlib-tool
-#   swift-update
-#   swiftc
+  ln -s ${buildPackages.gperf}/bin/gperf $out/usr/bin/gperf
+  ln -s ${buildPackages.indent}/bin/indent $out/usr/bin/indent
+  ln -s ${buildPackages.ctags}/bin/ctags $out/usr/bin/ctags
+'' + optionalString stdenv.isDarwin ''
+  ln -s ${buildPackages.darwin.bootstrap_cmds}/bin/mig $out/usr/bin
+  ln -s ${mkdep-darwin-src} $out/usr/bin/mkdep
+'')

pkgs/development/tools/xcbuild/wrapper.nix

···
-{ stdenv, callPackage, makeWrapper, writeText, CoreServices, ImageIO, CoreGraphics
-, cctools, bootstrap_cmds, binutils}:
+{ stdenv, buildPackages, makeWrapper, writeText, runCommand
+, CoreServices, ImageIO, CoreGraphics }:
 
 let
 
···
   platformName = "com.apple.platform.macosx";
   sdkName = "macosx10.10";
 
-  xcbuild = callPackage ./default.nix {
+  xcbuild = buildPackages.callPackage ./default.nix {
     inherit CoreServices ImageIO CoreGraphics;
   };
 
-  toolchain = callPackage ./toolchain.nix {
-    inherit cctools bootstrap_cmds toolchainName xcbuild binutils stdenv;
+  toolchain = buildPackages.callPackage ./toolchain.nix {
+    inherit toolchainName;
   };
 
-  sdk = callPackage ./sdk.nix {
-    inherit toolchainName sdkName xcbuild;
+  sdk = buildPackages.callPackage ./sdk.nix {
+    inherit toolchainName sdkName;
   };
 
-  platform = callPackage ./platform.nix {
-    inherit sdk platformName xcbuild;
+  platform = buildPackages.callPackage ./platform.nix {
+    inherit sdk platformName;
   };
 
   xcconfig = writeText "nix.xcconfig" ''
···
 stdenv.mkDerivation {
   name = "xcbuild-wrapper-${xcbuild.version}";
 
-  buildInputs = [ xcbuild makeWrapper ];
+  nativeBuildInputs = [ makeWrapper ];
 
   setupHook = ./setup-hook.sh;
 
···
 
   installPhase = ''
     mkdir -p $out/bin
-    cd $out/bin/
 
     for file in ${xcbuild}/bin/*; do
-      ln -s $file
+      ln -s $file $out/bin
     done
 
-    mkdir $out/usr
+    mkdir -p $out/usr
     ln -s $out/bin $out/usr/bin
 
-    mkdir -p $out/Library/Xcode/
+    mkdir -p $out/Library/Xcode
     ln -s ${xcbuild}/Library/Xcode/Specifications $out/Library/Xcode/Specifications
 
-    mkdir -p $out/Platforms/
+    mkdir -p $out/Platforms
     ln -s ${platform} $out/Platforms/nixpkgs.platform
 
-    mkdir -p $out/Toolchains/
+    mkdir -p $out/Toolchains
     ln -s ${toolchain} $out/Toolchains/nixpkgs.xctoolchain
 
     wrapProgram $out/bin/xcodebuild \

pkgs/top-level/all-packages.nix

···
 
   xcbuild  = callPackage ../development/tools/xcbuild/wrapper.nix {
     inherit (darwin.apple_sdk.frameworks) CoreServices CoreGraphics ImageIO;
-    inherit (darwin) cctools bootstrap_cmds binutils;
-    stdenv = clangStdenv;
+    stdenv = buildPackages.clangStdenv;
   };
 
   xmlindent = callPackage ../development/web/xmlindent {};