[WIP] Add 'perSystem' and 'systems' schema attributes

flake.nix

@@ -702,5 +702,15 @@
         // { default = self.devShells.${system}.stdenv; }
       );
 
+
+
+
+      perSystem = {system}: {
+        packages.a = nixpkgsFor.${system}.bash;
+        packages.default = nixpkgsFor.${system}.bash; # Overwrites default package
+      };
+
+      #systems = linuxSystems ++ [ "x86_64-darwin"  ];
+      inherit systems;
   };
 }

src/libexpr/flake/call-flake.nix

@@ -1,6 +1,94 @@
 lockFileStr: rootSrc: rootSubdir:
 
 let
+  inherit (builtins) listToAttrs concatMap attrNames mapAttrs isAttrs isList foldl';
+  optionalAttrs = check: value: if check then value else { };
+
+  mergeAny = lhs: rhs:
+    lhs // mapAttrs
+      (name: value:
+        if isAttrs value then lhs.${name} or { } // value
+        else if isList value then lhs.${name} or [ ] ++ value
+        else value
+      )
+      rhs;
+
+  eachSystem = systems: f:
+    let
+      # Taken from <nixpkgs/lib/attrsets.nix>
+      isDerivation = x: builtins.isAttrs x && x ? type && x.type == "derivation";
+
+      # Used to match Hydra's convention of how to define jobs. Basically transforms
+      #
+      #     hydraJobs = {
+      #       hello = <derivation>;
+      #       haskellPackages.aeson = <derivation>;
+      #     }
+      #
+      # to
+      #
+      #     hydraJobs = {
+      #       hello.x86_64-linux = <derivation>;
+      #       haskellPackages.aeson.x86_64-linux = <derivation>;
+      #     }
+      #
+      # if the given flake does `eachSystem [ "x86_64-linux" ] { ... }`.
+      pushDownSystem = system: merged:
+        builtins.mapAttrs
+          (name: value:
+            if ! (builtins.isAttrs value) then value
+            else if isDerivation value then (merged.${name} or { }) // { ${system} = value; }
+            else pushDownSystem system (merged.${name} or { }) value);
+
+      # Merge together the outputs for all systems.
+      op = attrs: system:
+        let
+          ret = f system;
+          op = attrs: key:
+            let
+              appendSystem = key: system: ret:
+                if key == "hydraJobs"
+                then (pushDownSystem system (attrs.hydraJobs or { }) ret.hydraJobs)
+                else { ${system} = ret.${key}; };
+            in
+            attrs //
+            {
+              ${key} = (attrs.${key} or { })
+              // (appendSystem key system ret);
+            }
+          ;
+        in
+        builtins.foldl' op attrs (builtins.attrNames ret);
+    in
+    builtins.foldl' op { } systems
+  ;
+
+  merger = flake:
+    let
+      filterAttrs = pred: set:
+        listToAttrs (concatMap (name: let value = set.${name}; in if pred name value then [ ({ inherit name value; }) ] else [ ]) (attrNames set));
+
+      systems = flake.systems or [ ];
+    in
+    mergeAny flake (
+      eachSystem systems (system:
+        let
+          systemOutputs = flake.perSystem { inherit system; };
+          otherArguments = flake;
+
+          mkOutputs = attrs: output:
+            attrs //
+            mergeAny
+              # prevent override of nested outputs in otherArguments
+              (optionalAttrs (otherArguments ? ${output}.${system})
+                { ${output} = otherArguments.${output}.${system}; })
+              (optionalAttrs (systemOutputs ? ${output})
+                { ${output} = systemOutputs.${output}; });
+        in
+        (foldl' mkOutputs { } (attrNames systemOutputs))
+      )
+    )
+  ;
 
   lockFile = builtins.fromJSON lockFileStr;
 
@@ -12,45 +100,46 @@ let
           sourceInfo =
             if key == lockFile.root
             then rootSrc
-            else fetchTree (node.info or {} // removeAttrs node.locked ["dir"]);
+            else fetchTree (node.info or { } // removeAttrs node.locked [ "dir" ]);
 
           subdir = if key == lockFile.root then rootSubdir else node.locked.dir or "";
 
           flake = import (sourceInfo + (if subdir != "" then "/" else "") + subdir + "/flake.nix");
 
           inputs = builtins.mapAttrs
             (inputName: inputSpec: allNodes.${resolveInput inputSpec})
-            (node.inputs or {});
+            (node.inputs or { });
 
           # Resolve a input spec into a node name. An input spec is
           # either a node name, or a 'follows' path from the root
           # node.
           resolveInput = inputSpec:
-              if builtins.isList inputSpec
-              then getInputByPath lockFile.root inputSpec
-              else inputSpec;
+            if builtins.isList inputSpec
+            then getInputByPath lockFile.root inputSpec
+            else inputSpec;
 
           # Follow an input path (e.g. ["dwarffs" "nixpkgs"]) from the
           # root node, returning the final node.
           getInputByPath = nodeName: path:
-            if path == []
+            if path == [ ]
             then nodeName
             else
               getInputByPath
                 # Since this could be a 'follows' input, call resolveInput.
                 (resolveInput lockFile.nodes.${nodeName}.inputs.${builtins.head path})
                 (builtins.tail path);
 
-          outputs = flake.outputs (inputs // { self = result; });
+          outputs = merger (flake.outputs (inputs // { self = result; }));
 
           result = outputs // sourceInfo // { inherit inputs; inherit outputs; inherit sourceInfo; };
         in
-          if node.flake or true then
-            assert builtins.isFunction flake.outputs;
-            result
-          else
-            sourceInfo
+        if node.flake or true then
+          assert builtins.isFunction flake.outputs;
+          result
+        else
+          sourceInfo
       )
       lockFile.nodes;
 
-in allNodes.${lockFile.root}
+in
+allNodes.${lockFile.root}

src/nix/flake.cc

@@ -1132,7 +1132,8 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
                     }
                 }
 
-                else {
+                // Ignore 'systems' and 'perSystem' attributes
+                else if (!(attrPathS[0] == "systems" || attrPathS[0] == "perSystem")) {
                     auto [type, description] =
                         (attrPath.size() == 1 && attrPathS[0] == "overlay")
                         || (attrPath.size() == 2 && attrPathS[0] == "overlays") ? std::make_pair("nixpkgs-overlay", "Nixpkgs overlay") :

test.sh

@@ -0,0 +1,4 @@
+make -j $NIX_BUILD_CORES
+make install
+
+./outputs/out/bin/nix flake show --extra-experimental-features nix-command --extra-experimental-features flakes