refactor: only support i686-linux for foundation gcc

foundation/flake.lock

@@ -3,10 +3,10 @@
     "lib": {
       "locked": {
         "dir": "lib",
-        "dirtyRev": "a707b0f06be6b36bcbfe88d0a9a5b9a803983a06-dirty",
+        "dirtyRev": "2be3111b2c0911f40b47fe0a1fb22b5f5188cf59-dirty",
-        "dirtyShortRev": "a707b0f-dirty",
+        "dirtyShortRev": "2be3111-dirty",
-        "lastModified": 1719079124,
+        "lastModified": 1719251485,
-        "narHash": "sha256-4HwA3q5f7SUBmcXX9Vz9WsA9oHBQ/GiZTwE4iSVq9s8=",
+        "narHash": "sha256-63NvfFVeTDITfNu60rmCUlaZtAeZUnvrIaOLSk9ScC8=",
         "type": "git",
         "url": "file:../?dir=lib"
       },

lib/src/options/default.nix

@@ -4,184 +4,166 @@ lib: {
       ## Merge a list of option definitions into a single value.
       ##
       ## @type Location -> List Definition -> Any
-      default =
+      default = location: definitions: let
-        location: definitions:
+        values = lib.options.getDefinitionValues definitions;
-        let
+        first = builtins.elemAt values 0;
-          values = lib.options.getDefinitionValues definitions;
+        mergedFunctions = x: lib.options.mergeDefault location (builtins.map (f: f x) values);
-          first = builtins.elemAt values 0;
+        mergedLists = builtins.concatLists values;
-          mergedFunctions = x: lib.options.mergeDefault location (builtins.map (f: f x) values);
+        mergedAttrs = builtins.foldl' lib.attrs.merge {} values;
-          mergedLists = builtins.concatLists values;
+        mergedBools = builtins.any lib.bools.or false values;
-          mergedAttrs = builtins.foldl' lib.attrs.merge { } values;
+        mergedStrings = lib.strings.concat values;
-          mergedBools = builtins.any lib.bools.or false values;
+      in
-          mergedStrings = lib.strings.concat values;
+        if builtins.length values == 1
-        in
+        then builtins.elemAt values 0
-        if builtins.length values == 1 then
+        else if builtins.all builtins.isFunction values
-          builtins.elemAt values 0
+        then mergedFunctions
-        else if builtins.all builtins.isFunction values then
+        else if builtins.all builtins.isList values
-          mergedFunctions
+        then mergedLists
-        else if builtins.all builtins.isList values then
+        else if builtins.all builtins.isAttrs values
-          mergedLists
+        then mergedAttrs
-        else if builtins.all builtins.isAttrs values then
+        else if builtins.all builtins.isBool values
-          mergedAttrs
+        then mergedBools
-        else if builtins.all builtins.isBool values then
+        else if builtins.all lib.strings.isString values
-          mergedBools
+        then mergedStrings
-        else if builtins.all lib.strings.isString values then
+        else if builtins.all builtins.isInt values && builtins.all (x: x == first) values
-          mergedStrings
+        then first
-        else if builtins.all builtins.isInt values && builtins.all (x: x == first) values then
-          first
         # TODO: Improve this error message to show the location and definitions for the option.
-        else
+        else builtins.throw "Cannot merge definitions.";
-          builtins.throw "Cannot merge definitions.";
 
       ## Merge multiple option definitions together.
       ##
       ## @type Location -> Type -> List Definition
-      definitions =
+      definitions = location: type: definitions: let
-        location: type: definitions:
+        identifier = lib.options.getIdentifier location;
-        let
+        resolve = definition: let
-          identifier = lib.options.getIdentifier location;
+          properties = builtins.addErrorContext "while evaluating definitions from `${definition.__file__ or "<unknown>"}`:" (
-          resolve =
+            lib.modules.apply.properties definition.value
-            definition:
+          );
-            let
+          normalize = value: {
-              properties = builtins.addErrorContext "while evaluating definitions from `${definition.__file__}`:" (
+            __file__ = definition.__file__;
-                lib.modules.apply.properties definition.value
+            inherit value;
-              );
-              normalize = value: {
-                __file__ = definition.__file__;
-                inherit value;
-              };
-            in
-            builtins.map normalize properties;
-
-          resolved = builtins.concatMap resolve definitions;
-          overridden = lib.modules.apply.overrides resolved;
-
-          values =
-            if builtins.any (definition: lib.types.is "order" definition.value) overridden.values then
-              lib.modules.apply.order overridden.values
-            else
-              overridden.values;
-
-          isDefined = values != [ ];
-
-          invalid = builtins.filter (definition: !(type.check definition.value)) values;
-
-          merged =
-            if isDefined then
-              if builtins.all (definition: type.check definition.value) values then
-                type.merge location values
-              else
-                builtins.throw "A definition for `${identifier}` is not of type `${type.description}`. Definition values:${lib.options.getDefinitions invalid}"
-            else
-              builtins.throw "The option `${identifier}` is used but not defined.";
-
-          optional = if isDefined then { value = merged; } else { };
-        in
-        {
-          inherit
-            isDefined
-            values
-            merged
-            optional
-            ;
-
-          raw = {
-            inherit values;
-            inherit (overridden) highestPriority;
           };
+        in
+          builtins.map normalize properties;
+
+        resolved = builtins.concatMap resolve definitions;
+        overridden = lib.modules.apply.overrides resolved;
+
+        values =
+          if builtins.any (definition: lib.types.is "order" definition.value) overridden.values
+          then lib.modules.apply.order overridden.values
+          else overridden.values;
+
+        isDefined = values != [];
+
+        invalid = builtins.filter (definition: !(type.check definition.value)) values;
+
+        merged =
+          if isDefined
+          then
+            if builtins.all (definition: type.check definition.value) values
+            then type.merge location values
+            else builtins.throw "A definition for `${identifier}` is not of type `${type.description}`. Definition values:${lib.options.getDefinitions invalid}"
+          else builtins.throw "The option `${identifier}` is used but not defined.";
+
+        optional =
+          if isDefined
+          then {value = merged;}
+          else {};
+      in {
+        inherit
+          isDefined
+          values
+          merged
+          optional
+          ;
+
+        raw = {
+          inherit values;
+          inherit (overridden) highestPriority;
         };
+      };
 
       ## Merge multiple option declarations together.
       ##
       ## @type Location -> List Option
-      declarations =
+      declarations = location: options: let
-        location: options:
+        merge = result: option: let
-        let
+          mergedType = result.type.mergeType option.options.type.functor;
-          merge =
+          isTypeMergeable = mergedType != null;
-            result: option:
+          shared = name: option.options ? ${name} && result ? ${name};
-            let
+          typeSet = lib.attrs.when ((shared "type") && isTypeMergeable) {type = mergedType;};
-              mergedType = result.type.mergeType option.options.type.functor;
+          files = result.declarations;
-              isTypeMergeable = mergedType != null;
+          serializedFiles = builtins.concatStringsSep " and " files;
-              shared = name: option.options ? ${name} && result ? ${name};
+          getSubModules = option.options.type.getSubModules or null;
-              typeSet = lib.attrs.when ((shared "type") && isTypeMergeable) { type = mergedType; };
+          submodules =
-              files = result.declarations;
+            if getSubModules != null
-              serializedFiles = builtins.concatStringsSep " and " files;
-              getSubModules = option.options.type.getSubModules or null;
-              submodules =
-                if getSubModules != null then
-                  builtins.map (module: {
-                    __file__ = option.__file__;
-                    includes = [ module ];
-                  }) getSubModules
-                  ++ result.options
-                else
-                  result.options;
-            in
-            if
-              shared "default"
-              || shared "example"
-              || shared "description"
-              || shared "apply"
-              || (shared "type" && !isTypeMergeable)
             then
-              builtins.throw "The option `${lib.options.getIdentifier location}` in `${option.__file__}` is already declared in ${serializedFiles}"
+              builtins.map (module: {
-            else
+                __file__ = option.__file__;
-              option.options
+                includes = [module];
-              // result
+              })
-              // {
+              getSubModules
-                declarations = result.declarations ++ [ option.__file__ ];
+              ++ result.options
-                options = submodules;
+            else result.options;
-              }
-              // typeSet;
         in
+          if
+            shared "default"
+            || shared "example"
+            || shared "description"
+            || shared "apply"
+            || (shared "type" && !isTypeMergeable)
+          then builtins.throw "The option `${lib.options.getIdentifier location}` in `${option.__file__}` is already declared in ${serializedFiles}"
+          else
+            option.options
+            // result
+            // {
+              declarations = result.declarations ++ [option.__file__];
+              options = submodules;
+            }
+            // typeSet;
+      in
         builtins.foldl' merge {
           inherit location;
-          declarations = [ ];
+          declarations = [];
-          options = [ ];
+          options = [];
-        } options;
+        }
+        options;
 
       ## Merge an option, only supporting a single unique definition.
       ##
       ## @type String -> Location -> List Definition -> Any
-      unique =
+      unique = message: location: definitions: let
-        message: location: definitions:
+        identifier = lib.options.getIdentifier location;
-        let
+        total = builtins.length definitions;
-          identifier = lib.options.getIdentifier location;
+        first = builtins.elemAt definitions 0;
-          total = builtins.length definitions;
+      in
-          first = builtins.elemAt definitions 0;
+        if total == 1
-        in
+        then first.value
-        if total == 1 then
+        else if total == 0
-          first.value
+        then builtins.throw "Cannot merge unused option `${identifier}`.\n${message}"
-        else if total == 0 then
+        else builtins.throw "The option `${identifier}` is defined multiple times, but must be unique.\n${message}\nDefinitions:${lib.options.getDefinitions definitions}";
-          builtins.throw "Cannot merge unused option `${identifier}`.\n${message}"
-        else
-          builtins.throw "The option `${identifier}` is defined multiple times, but must be unique.\n${message}\nDefinitions:${lib.options.getDefinitions definitions}";
 
       ## Merge a single instance of an option.
       ##
       ## @type Location -> List Definition -> Any
       one = lib.options.merge.unique "";
 
-      equal =
+      equal = location: definitions: let
-        location: definitions:
+        identifier = lib.options.getIdentifier location;
-        let
+        first = builtins.elemAt definitions 0;
-          identifier = lib.options.getIdentifier location;
+        rest = builtins.tail definitions;
-          first = builtins.elemAt definitions 0;
+        merge = x: y:
-          rest = builtins.tail definitions;
+          if x != y
-          merge =
+          then builtins.throw "The option `${identifier}` has conflicting definitions:${lib.options.getDefinitions definitions}"
-            x: y:
+          else x;
-            if x != y then
+        merged = builtins.foldl' merge first rest;
-              builtins.throw "The option `${identifier}` has conflicting definitions:${lib.options.getDefinitions definitions}"
+      in
-            else
+        if builtins.length definitions == 0
-              x;
+        then builtins.throw "Cannot merge unused option `${identifier}`."
-          merged = builtins.foldl' merge first rest;
+        else if builtins.length definitions == 1
-        in
+        then first.value
-        if builtins.length definitions == 0 then
+        else merged.value;
-          builtins.throw "Cannot merge unused option `${identifier}`."
-        else if builtins.length definitions == 1 then
-          first.value
-        else
-          merged.value;
     };
 
     ## Check whether a value is an option.
@@ -192,50 +174,46 @@ lib: {
     ## Create an option.
     ##
     ## @type { type? :: String | Null, apply? :: (a -> b) | Null, default? :: { value :: a, text :: String }, example? :: String | Null, visible? :: Bool | Null, internal? :: Bool | Null, writable? :: Bool | Null, description? :: String | Null } -> Option a
-    create =
+    create = settings @ {
-      settings@{
+      type ? lib.types.unspecified,
-        type ? lib.types.unspecified,
+      apply ? null,
-        apply ? null,
+      default ? {},
-        default ? { },
+      example ? null,
-        example ? null,
+      visible ? null,
-        visible ? null,
+      internal ? null,
-        internal ? null,
+      writable ? null,
-        writable ? null,
+      description ? null,
-        description ? null,
+    }: {
-      }:
+      __type__ = "option";
-      {
+      inherit
-        __type__ = "option";
+        type
-        inherit
+        apply
-          type
+        default
-          apply
+        example
-          default
+        visible
-          example
+        internal
-          visible
+        writable
-          internal
+        description
-          writable
+        ;
-          description
+    };
-          ;
-      };
 
     ## Create a sink option.
     ##
     ## @type @alias lib.options.create
-    sink =
+    sink = settings: let
-      settings:
+      defaults = {
-      let
+        internal = true;
-        defaults = {
+        visible = false;
-          internal = true;
+        default = false;
-          visible = false;
+        description = "A sink option for unused definitions";
-          default = false;
+        type = lib.types.create {
-          description = "A sink option for unused definitions";
+          name = "sink";
-          type = lib.types.create {
+          check = lib.fp.const true;
-            name = "sink";
+          merge = lib.fp.const (lib.fp.const false);
-            check = lib.fp.const true;
-            merge = lib.fp.const (lib.fp.const false);
-          };
-          apply = value: builtins.throw "Cannot read the value of a Sink option.";
         };
-      in
+        apply = value: builtins.throw "Cannot read the value of a Sink option.";
+      };
+    in
       lib.options.create (defaults // settings);
 
     ## Get the definition values from a list of options definitions.
@@ -246,94 +224,93 @@ lib: {
     ## Convert a list of option identifiers into a single identifier.
     ##
     ## @type List String -> String
-    getIdentifier =
+    getIdentifier = location: let
-      location:
+      special = [
-      let
+        # lib.types.attrs.of (lib.types.submodule {})
-        special = [
+        "<name>"
-          # lib.types.attrs.of (lib.types.submodule {})
+        # lib.types.list.of (submodule {})
-          "<name>"
+        "*"
-          # lib.types.list.of (submodule {})
+        # lib.types.function
-          "*"
+        "<function body>"
-          # lib.types.function
+      ];
-          "<function body>"
+      escape = part:
-        ];
+        if builtins.elem part special
-        escape = part: if builtins.elem part special then part else lib.strings.escape.nix.identifier part;
+        then part
-      in
+        else lib.strings.escape.nix.identifier part;
+    in
       lib.strings.concatMapSep "." escape location;
 
     ## Get a string message of the definitions for an option.
     ##
     ## @type List Definition -> String
-    getDefinitions =
+    getDefinitions = definitions: let
-      definitions:
+      serialize = definition: let
-      let
+        valueWithRecursionLimit =
-        serialize =
+          lib.generators.withRecursion {
-          definition:
+            limit = 10;
-          let
+            throw = false;
-            valueWithRecursionLimit = lib.generators.withRecursion {
+          }
-              limit = 10;
+          definition.value;
-              throw = false;
-            } definition.value;
 
-            eval = builtins.tryEval (lib.generators.pretty { } valueWithRecursionLimit);
+        eval = builtins.tryEval (lib.generators.pretty {} valueWithRecursionLimit);
 
-            lines = lib.strings.split "\n" eval.value;
+        lines = lib.strings.split "\n" eval.value;
-            linesLength = builtins.length lines;
+        linesLength = builtins.length lines;
-            firstFiveLines = lib.lists.take 5 lines;
+        firstFiveLines = lib.lists.take 5 lines;
 
-            ellipsis = lib.lists.when (linesLength > 5) "...";
+        ellipsis = lib.lists.when (linesLength > 5) "...";
 
-            value = builtins.concatStringsSep "\n    " (firstFiveLines ++ ellipsis);
+        value = builtins.concatStringsSep "\n    " (firstFiveLines ++ ellipsis);
 
-            result =
+        result =
-              if !eval.success then
+          if !eval.success
-                ""
+          then ""
-              else if linesLength > 1 then
+          else if linesLength > 1
-                ":\n    " + value
+          then ":\n    " + value
-              else
+          else ": " + value;
-                ": " + value;
+      in "\n- In `${definition.__file__}`${result}";
-          in
+    in
-          "\n- In `${definition.__file__}`${result}";
-      in
       lib.strings.concatMap serialize definitions;
 
     ## Run a set of definitions, calculating the resolved value and associated information.
     ##
     ## @type Location -> Option -> List Definition -> String & { value :: Any, highestPriority :: Int, isDefined :: Bool, files :: List String, definitions :: List Any, definitionsWithLocations :: List Definition }
-    run =
+    run = location: option: definitions: let
-      location: option: definitions:
+      identifier = lib.options.getIdentifier location;
-      let
-        identifier = lib.options.getIdentifier location;
 
-        definitionsWithDefault =
+      definitionsWithDefault =
-          if option ? default && option.default ? value then
+        if option ? default && option.default ? value
-            [
+        then
-              {
+          [
-                __file__ = builtins.head option.declarations;
+            {
-                value = lib.modules.overrides.option option.default.value;
+              __file__ = builtins.head option.declarations;
-              }
+              value = lib.modules.overrides.option option.default.value;
-            ]
+            }
-            ++ definitions
+          ]
-          else
+          ++ definitions
-            definitions;
+        else definitions;
 
-        merged =
+      merged =
-          if option.writable or null == false && builtins.length definitionsWithDefault > 1 then
+        if option.writable or null == false && builtins.length definitionsWithDefault > 1
-            let
+        then let
-              separatedDefinitions = builtins.map (
+          separatedDefinitions =
-                definition:
+            builtins.map (
+              definition:
                 definition
                 // {
-                  value = (lib.options.merge.definitions location option.type [ definition ]).merged;
+                  value = (lib.options.merge.definitions location option.type [definition]).merged;
                 }
-              ) definitionsWithDefault;
+            )
-            in
+            definitionsWithDefault;
-            builtins.throw "The option `${identifier}` is not writable, but is set more than once:${lib.options.getDefinitions separatedDefinitions}"
+        in
-          else
+          builtins.throw "The option `${identifier}` is not writable, but is set more than once:${lib.options.getDefinitions separatedDefinitions}"
-            lib.options.merge.definitions location option.type definitionsWithDefault;
+        else lib.options.merge.definitions location option.type definitionsWithDefault;
 
-        value = if option.apply or null != null then option.apply merged.merged else merged.merged;
+      value =
-      in
+        if option.apply or null != null
+        then option.apply merged.merged
+        else merged.merged;
+    in
       option
       // {
         value = builtins.addErrorContext "while evaluating the option `${identifier}`:" value;

lib/src/types/default.nix

@@ -1048,7 +1048,7 @@ lib: {
           merge = location: definitions: let
             process = value:
               if initial.check value
-              then (builtins.trace "transforming...") transform value
+              then  transform value
               else value;
             normalize = definition: definition // {value = process definition.value;};
             normalized = builtins.map normalize definitions;
@@ -1068,6 +1068,43 @@ lib: {
           };
         };
 
+    ## Create a type that allows a value which is either the final type or is transformable
+    ## to the final type.
+    ##
+    ## @type Attrs -> (Any -> Any) -> Attrs -> Attrs
+    coerceWithLocation = initial: transform: final: let
+    in
+      if initial.getSubModules != null
+      then builtins.throw "lib.types.coerceWithLocation's first argument may not have submodules, but got ${initial.description}"
+      else
+        lib.types.create {
+          name = "Coerce";
+          description = "${initial.description} that is transformed to ${final.description}";
+          fallback = final.fallback;
+          check = value: final.check value || (initial.check value && final.check (transform [] value));
+          merge = location: definitions: let
+            process = value:
+              if initial.check value
+              then transform location value
+              else value;
+            normalize = definition: definition // {value = process definition.value;};
+            normalized = builtins.map normalize definitions;
+          in
+            final.merge location normalized;
+          getSubOptions = final.getSubOptions;
+          getSubModules = final.getSubModules;
+          withSubModules = modules: lib.types.coerceWithLocation initial transform (final.withSubModules modules);
+          mergeType = x: y: null;
+          functor =
+            lib.types.functor "coerceWithLocation"
+            // {
+              wrapped = final;
+            };
+          children = {
+            inherit initial final;
+          };
+        };
+
     dag = {
       ## Create a type that allows a DAG (Directed Acyclic Graph) of a given type.
       ##

tidepool/flake.lock

@@ -8,10 +8,10 @@
       },
       "locked": {
         "dir": "foundation",
-        "dirtyRev": "a707b0f06be6b36bcbfe88d0a9a5b9a803983a06-dirty",
+        "dirtyRev": "2be3111b2c0911f40b47fe0a1fb22b5f5188cf59-dirty",
-        "dirtyShortRev": "a707b0f-dirty",
+        "dirtyShortRev": "2be3111-dirty",
-        "lastModified": 1719079124,
+        "lastModified": 1719251485,
-        "narHash": "sha256-hz9vVcHSvlq/W01UOh/GqPFUoH9DzCFB16n23oj7fnQ=",
+        "narHash": "sha256-9G1TPBdlQNXCZf6A66bCT9m2vhodkSF+rDtqOVuFteY=",
         "type": "git",
         "url": "file:../?dir=foundation"
       },
@@ -24,10 +24,10 @@
     "lib": {
       "locked": {
         "dir": "lib",
-        "dirtyRev": "a707b0f06be6b36bcbfe88d0a9a5b9a803983a06-dirty",
+        "dirtyRev": "2be3111b2c0911f40b47fe0a1fb22b5f5188cf59-dirty",
-        "dirtyShortRev": "a707b0f-dirty",
+        "dirtyShortRev": "2be3111-dirty",
-        "lastModified": 1719079124,
+        "lastModified": 1719251485,
-        "narHash": "sha256-hz9vVcHSvlq/W01UOh/GqPFUoH9DzCFB16n23oj7fnQ=",
+        "narHash": "sha256-9G1TPBdlQNXCZf6A66bCT9m2vhodkSF+rDtqOVuFteY=",
         "type": "git",
         "url": "file:../?dir=lib"
       },

tidepool/src/builders/basic.nix

@@ -83,7 +83,13 @@ in {
           }
         );
       in
-        built // {inherit (package) meta;};
+        built
+        // {
+          inherit (package) meta;
+          extras = {
+            inherit package;
+          };
+        };
     };
   };
 }

tidepool/src/export.nix

@@ -1,16 +1,13 @@
 # This file handles creating all of the exports for this project and is not
 # exported itself.
-{
+{config}: let
-  lib,
+  inherit (config) lib;
-  config,
-}: let
-  lib' = config.lib;
 in {
-  freeform = lib.types.any;
+  # freeform = lib.types.any;
 
   config = {
     exports = {
-      lib = config.lib;
+      inherit lib;
       modules = import ./modules.nix;
 
       packages = {
@@ -25,13 +22,14 @@ in {
         #   };
         # }))
         # .config;
-        # foundation-gcc = config.packages.foundation.gcc;
+        foundation-gcc = config.packages.foundation.gcc;
         # foundation-binutils = config.packages.foundation.binutils;
         # foundation-linux-headers = config.packages.foundation.linux-headers.versions.latest.extend {
         #   platform.host = lib.modules.overrides.force "x86_64-linux";
         # };
         # example-x = config.packages.example.x;
-        # cross-example-x-x86_64-linux = config.packages.cross.x86_64-linux.example.x;
+        cross-aux-a-x86_64-linux = config.packages.cross.x86_64-linux.aux.a;
+        cross-foundation-gcc-x86_64-linux = config.packages.cross.x86_64-linux.foundation.gcc;
       };
     };
 

tidepool/src/lib/packages.nix

@@ -1,8 +1,9 @@
 {
   lib,
-  lib',
   config,
-}: {
+}: let
+  lib' = config.lib;
+in {
   config = {
     lib.packages = {
       dependencies = {
@@ -20,52 +21,70 @@
       in
         builtins.head sorted;
 
-      resolve = package:
+      resolve = alias:
-        if package ? versions
+        if alias ? versions
         then
-          package.versions.${config.preferences.packages.version}
+          alias.versions.${config.preferences.packages.version}
-          or (package.versions.${lib'.packages.getLatest package})
+          or (alias.versions.${lib'.packages.getLatest alias})
-        else package;
+        else alias;
 
-      build = package: build: host: target: let
+      build = alias: build: host: target: let
-        resolved = lib'.packages.resolve package;
+        package = lib'.packages.resolve alias;
 
         buildDependencies = build': host': target':
           builtins.mapAttrs (name: dep: lib'.packages.build dep build' host' target');
 
-        result = resolved.extend (
+        result = lib.modules.run {
-          {config}: {
+          modules =
-            config = {
+            package.__modules__
-              platform = {
+            ++ [
-                build = build;
+              lib'.types.package.children.submodule
-                host = host;
+              (
-                target = lib.modules.override 150 target;
+                {config}: {
-              };
+                  config = {
+                    __modules__ = package.__modules__;
 
-              deps = {
+                    platform = {
-                build = {
+                      build = lib.modules.overrides.force build;
-                  only = buildDependencies build build build resolved.deps.build.only;
+                      host = lib.modules.overrides.force host;
-                  build = buildDependencies build build target resolved.deps.build.build;
+                      target = lib.modules.overrides.force target;
-                  host = buildDependencies build host target resolved.deps.build.host;
+                    };
-                  target = buildDependencies build target target resolved.deps.build.target;
+                  };
-                };
+                }
-                host = {
+              )
-                  only = buildDependencies host host host resolved.deps.host.only;
+            ];
-                  host = buildDependencies host host target resolved.deps.host.host;
+        };
-                  target = buildDependencies host target target resolved.deps.host.target;
-                };
-                target = {
-                  only = buildDependencies target target target resolved.deps.target.only;
-                  target = buildDependencies target target target resolved.deps.target.target;
-                };
-              };
 
-              package = config.builder.build config;
+        # Not all platform information can be effectively handled via submodules. To handle
+        # the case where a user copies the resolved config over we need to ensure that
+        # dependencies are appropriately updated.
+        resolved =
+          result.config
+          // {
+            deps = {
+              build = {
+                only = buildDependencies build build build package.deps.build.only;
+                build = buildDependencies build build target package.deps.build.build;
+                host = buildDependencies build host target package.deps.build.host;
+                target = buildDependencies build target target package.deps.build.target;
+              };
+              host = {
+                only = buildDependencies host host host package.deps.host.only;
+                host = buildDependencies host host target package.deps.host.host;
+                target = buildDependencies host target target package.deps.host.target;
+              };
+              target = {
+                only = buildDependencies target target target package.deps.target.only;
+                target = buildDependencies target target target package.deps.target.target;
+              };
             };
-          }
+          };
-        );
+
       in
-        result;
+        resolved
+        // {
+          package = resolved.builder.build resolved;
+        };
     };
   };
 }

tidepool/src/lib/types.nix

@@ -1,8 +1,11 @@
 {
   lib,
-  lib',
   config,
-}: {
+}: let
+  inherit (config) preferences builders;
+
+  lib' = config.lib;
+in {
   config = {
     lib.types = {
       license = let
@@ -52,6 +55,12 @@
       in
         lib.types.either type (lib.types.list.of type);
 
+      platform =
+        lib.types.coerce
+        lib.types.string
+        lib'.systems.withBuildInfo
+        lib'.systems.types.platformWithBuildInfo;
+
       builder = lib.types.submodule {
         freeform = lib.types.any;
 
@@ -63,385 +72,291 @@
         };
       };
 
-      packages = lib.types.attrs.of (lib'.types.alias);
+      packages = lib.types.attrs.of (lib.types.attrs.of lib'.types.alias);
 
-      alias = lib.types.attrs.of (
+      dependencies = build: host: target: let
-        lib.types.submodule {
+        initial = lib.types.attrs.any;
-          options = {
-            versions = lib.options.create {
-              description = "All available package versions.";
-              type = lib.types.attrs.of lib'.types.package.base;
-            };
-          };
-        }
-      );
 
-      dependencies = lib.types.attrs.of (
+        transform = value: let
-        lib.types.nullish (lib'.types.package.resolved)
+          package = lib'.packages.resolve value;
-      );
-
-      package = {
-        resolved = let
-          initial =
-            lib.types.raw
-            // {
-              check = value:
-                !(value ? __merged__)
-                && lib.types.raw.check
-                value;
-            };
-
-          transform = value: let
-            package = lib'.packages.resolve value;
-            packageSubmodule = package.extend (args: {
-              options.__export__ = lib.options.create {
-                type = lib.types.raw;
-                default.value = {
-                  inherit (args) options config;
-                };
-              };
-
-              config.__export__ = {
-                inherit (args) options config;
-              };
-            });
-            type = lib'.types.package.base.withSubModules (lib'.types.package.base.getSubModules
-              ++ [
-                (args: {
-                  options.__export__ = lib.options.create {
-                    type = lib.types.raw;
-                    default.value = {
-                      inherit (args) options config;
-                    };
-                  };
-
-                  config.__export__ = {
-                    inherit (args) options config;
-                  };
-                })
-              ]);
-            typeSubmodule = lib.modules.run {
-              modules = type.getSubModules;
-              args = type.functor.payload.args;
-            };
-
-            getOptions = export: let
-              process = path: option:
-                if builtins.isAttrs option
-                then
-                  if lib.types.is "option" option
-                  then [
-                    {
-                      inherit path;
-                      option = option;
-                    }
-                  ]
-                  else
-                    builtins.concatLists (
-                      lib.attrs.mapToList
-                      (name: value: process (path ++ [name]) value)
-                      option
-                    )
-                else [];
-            in
-              process [] export.options;
-
-            packageOptions = getOptions packageSubmodule.__export__;
-            typeOptions = getOptions typeSubmodule.config.__export__;
-
-            customOptions =
-              builtins.filter
-              (
-                packageOption:
-                  builtins.all (typeOption: packageOption.path != typeOption.path) typeOptions
-              )
-              packageOptions;
-
-            packageOptionsIds = builtins.map (option: builtins.concatStringsSep "." option.path) packageOptions;
-            typeOptionsIds = builtins.map (option: builtins.concatStringsSep "." option.path) typeOptions;
-            customOptionsIds = builtins.map (option: builtins.concatStringsSep "." option.path) customOptions;
-
-            resolvedOptions =
-              builtins.foldl' (
-                resolved: option: let
-                  first = builtins.head option.path;
-                  generated = lib.attrs.set option.path option.option;
-                in
-                  if first == "__export__" || first == "__module__" || first == "__merged__"
-                  then resolved
-                  else lib.attrs.mergeRecursive resolved generated
-              ) {}
-              customOptions;
-          in
-            # (builtins.trace (builtins.deepSeq packageOptionsIds packageOptionsIds))
-            # (builtins.trace (builtins.deepSeq typeOptionsIds typeOptionsIds))
-            # (builtins.trace (builtins.deepSeq customOptionsIds customOptionsIds))
-            # (builtins.trace packageSubmodule.__export__.config)
-            (args: {
-              __file__ = packageSubmodule.__export__.config.__file__ or "virtual:tidepool/src/lib/types.nix";
-
-              options =
-                resolvedOptions
-                // {
-                  __merged__ = lib.options.create {
-                    type = lib.types.bool;
-                    default.value = true;
-                  };
-                };
-
-              config =
-                builtins.removeAttrs package ["extend" "package" "platform"]
-                // {
-                  platform = {
-                    build = lib.modules.overrides.default package.platform.build.triple;
-                    host = lib.modules.overrides.default package.platform.host.triple;
-                    target = lib.modules.overrides.default package.platform.target.triple;
-                  };
-                };
-              # // {
-              #   builder =
-              #     (builtins.trace "builder")
-              #     (builtins.trace (args.config ? builder))
-              #     lib.modules.alias
-              #     packageSubmodule.__export__.options.builder;
-              # };
-            });
         in
-          lib.types.coerce initial transform lib'.types.package.base;
+        (builtins.trace "building dependency ${package.name}: build=${build.triple} host=${host.triple} target=${target.triple}")
+          lib'.packages.build package build host target;
+      in
+        lib.types.attrs.of (lib.types.coerce initial transform lib'.types.package);
 
-        base = lib.types.submodule (
+      alias = lib.types.submodule {
-          {
+        options = {
-            config,
+          stable = lib.options.create {
-            meta,
+            description = "The stable version of the package.";
-          }: {
+            type = lib.types.nullish lib'.types.package;
-            options = {
+          };
-              extend = lib.options.create {
-                description = "Extend the package's submodules with additional configuration.";
-                type = lib.types.function lib.types.raw;
-                default.value = value: let
-                  result = meta.extend {
-                    modules =
-                      if builtins.isAttrs value
-                      then [{config = value;}]
-                      else lib.lists.from.any value;
-                  };
-                in
-                  result.config;
-              };
 
-              name = lib.options.create {
+          latest = lib.options.create {
-                description = "The name of the package.";
+            description = "The latest version of the package.";
-                type = lib.types.string;
+            type = lib'.types.package;
-                default = {
+          };
-                  text = "\${config.pname}-\${config.version}";
-                  value =
-                    if config.pname != null && config.version != null
-                    then "${config.pname}-${config.version}"
-                    else "";
-                };
-              };
 
-              pname = lib.options.create {
+          versions = lib.options.create {
-                description = "The program name for the package";
+            description = "Available versions of the package.";
+            type = lib.types.attrs.of lib'.types.package;
+            default.value = {};
+          };
+        };
+      };
+
+      package = let
+        normalize = value:
+          if builtins.isFunction value || builtins.isList value
+          then value
+          else if value ? __modules__
+          then value.__modules__
+          else {
+            config = value;
+          };
+
+        initial = lib.types.create {
+          name = "PackageConfig";
+          description = "configuration for a package";
+          check = value: builtins.isFunction value || builtins.isAttrs value || builtins.isList value;
+          merge = location: definitions: let
+            normalized =
+              builtins.map
+              (definition: lib.lists.from.any (normalize definition.value))
+              definitions;
+          in
+            builtins.concatLists
+            normalized;
+        };
+
+        transform = location: value: let
+          modules =
+            lib.lists.from.any (normalize value);
+
+          result = lib.modules.run {
+            prefix = location;
+            modules =
+              modules
+              ++ [submodule {config.__modules__ = modules;}];
+          };
+        in
+          result.config;
+
+        final = lib.types.attrs.any;
+
+        submodule = {config}: let
+          build = config.platform.build;
+          host = config.platform.host;
+          target = config.platform.target;
+        in {
+          options = {
+            __modules__ = lib.options.create {
+              description = "User specified modules for the package definition.";
+              type = lib.types.list.of (initial
+                // {
+                  merge = lib.options.merge.one;
+                });
+              # writable = false;
+              internal = true;
+              default.value = [];
+            };
+
+            meta = {
+              description = lib.options.create {
+                description = "The description for the package.";
                 type = lib.types.nullish lib.types.string;
                 default.value = null;
               };
 
-              version = lib.options.create {
+              homepage = lib.options.create {
-                description = "The version for the package.";
+                description = "The homepage for the package.";
-                type = lib.types.nullish lib.types.version;
+                type = lib.types.nullish lib.types.string;
                 default.value = null;
               };
 
-              meta = {
+              license = lib.options.create {
-                description = lib.options.create {
+                description = "The license for the package.";
-                  description = "The description for the package.";
+                type = lib.types.nullish lib'.types.license;
-                  type = lib.types.nullish lib.types.string;
+                default.value = null;
-                  default.value = null;
-                };
-
-                homepage = lib.options.create {
-                  description = "The homepage for the package.";
-                  type = lib.types.nullish lib.types.string;
-                  default.value = null;
-                };
-
-                license = lib.options.create {
-                  description = "The license for the package.";
-                  type = lib.types.nullish lib'.types.license;
-                  default.value = null;
-                };
-
-                free = lib.options.create {
-                  description = "Whether the package is free.";
-                  type = lib.types.bool;
-                  default.value = true;
-                };
-
-                insecure = lib.options.create {
-                  description = "Whether the package is insecure.";
-                  type = lib.types.bool;
-                  default.value = false;
-                };
-
-                broken = lib.options.create {
-                  description = "Whether the package is broken.";
-                  type = lib.types.bool;
-                  default.value = false;
-                };
-
-                main = lib.options.create {
-                  description = "The main entry point for the package.";
-                  type = lib.types.nullish lib.types.string;
-                  default.value = null;
-                };
-
-                platforms = lib.options.create {
-                  description = "The platforms the package supports.";
-                  type = lib.types.list.of lib.types.string;
-                  default.value = [];
-                };
               };
 
-              platform = {
+              free = lib.options.create {
+                description = "Whether the package is free.";
+                type = lib.types.bool;
+                default.value = true;
+              };
+
+              insecure = lib.options.create {
+                description = "Whether the package is insecure.";
+                type = lib.types.bool;
+                default.value = false;
+              };
+
+              broken = lib.options.create {
+                description = "Whether the package is broken.";
+                type = lib.types.bool;
+                default.value = false;
+              };
+
+              main = lib.options.create {
+                description = "The main entry point for the package.";
+                type = lib.types.nullish lib.types.string;
+                default.value = null;
+              };
+
+              platforms = lib.options.create {
+                description = "The platforms the package supports.";
+                type = lib.types.list.of lib.types.string;
+                default.value = [];
+              };
+            };
+
+            platform = {
+              build = lib.options.create {
+                description = "The build platform for the package.";
+                type = lib'.types.platform;
+                default.value = lib'.systems.withBuildInfo "x86_64-linux";
+              };
+
+              host = lib.options.create {
+                description = "The host platform for the package.";
+                type = lib'.types.platform;
+                default.value = lib'.systems.withBuildInfo "x86_64-linux";
+              };
+
+              target = lib.options.create {
+                description = "The target platform for the package.";
+                type = lib'.types.platform;
+                default.value = lib'.systems.withBuildInfo "x86_64-linux";
+              };
+            };
+
+            name = lib.options.create {
+              description = "The name of the package.";
+              type = lib.types.string;
+              default = {
+                text = "\${config.pname}-\${config.version}";
+                value =
+                  if config.pname != null && config.version != null
+                  then "${config.pname}-${config.version}"
+                  else "";
+              };
+            };
+
+            pname = lib.options.create {
+              description = "The program name for the package";
+              type = lib.types.nullish lib.types.string;
+              default.value = null;
+            };
+
+            version = lib.options.create {
+              description = "The version for the package.";
+              type = lib.types.nullish lib.types.version;
+              default.value = null;
+            };
+
+            builder = lib.options.create {
+              description = "The builder for the package.";
+              type = lib'.types.builder;
+            };
+
+            phases = lib.options.create {
+              description = "The phases for the package.";
+              type = lib.types.dag.of lib.types.string;
+              default.value = {};
+            };
+
+            env = lib.options.create {
+              description = "The environment for the package.";
+              type = lib.types.attrs.of lib.types.string;
+              default.value = {};
+            };
+
+            package = lib.options.create {
+              description = "The built derivation.";
+              type = lib.types.derivation;
+              default.value = config.builder.build config;
+            };
+
+            deps = {
+              build = {
+                only = lib.options.create {
+                  description = "Dependencies which are only used in the build environment.";
+                  type = lib'.types.dependencies build build build;
+                  default.value = {};
+                };
+
                 build = lib.options.create {
-                  description = "The build platform for the package.";
+                  description = "Dependencies which are created in the build environment and are executed in the build environment.";
-                  type = lib.types.string;
+                  type = lib'.types.dependencies build build target;
-                  default.value = "x86_64-linux";
+                  default.value = {};
-                  apply = raw: let
-                    system = lib'.systems.from.string raw;
-                    x = lib'.systems.withBuildInfo raw;
-                  in
-                    x;
                 };
 
                 host = lib.options.create {
-                  description = "The host platform for the package.";
+                  description = "Dependencies which are created in the build environment and are executed in the host environment.";
-                  type = lib.types.string;
+                  type = lib'.types.dependencies build host target;
-                  default.value = "x86_64-linux";
+                  default.value = {};
-                  # apply = raw: let
-                  #   system = lib'.systems.from.string raw;
-                  # in {
-                  #   inherit raw system;
-
-                  #   double = lib'.systems.into.double system;
-                  #   triple = lib'.systems.into.triple system;
-                  # };
-                  apply = raw: let
-                    system = lib'.systems.from.string raw;
-                    x = lib'.systems.withBuildInfo raw;
-                  in
-                    x;
                 };
 
                 target = lib.options.create {
-                  description = "The target platform for the package.";
+                  description = "Dependencies which are created in the build environment and are executed in the target environment.";
-                  type = lib.types.string;
+                  type = lib'.types.dependencies build target target;
-                  default.value = "x86_64-linux";
+                  default.value = {};
-                  # apply = raw: let
-                  #   system = lib'.systems.from.string raw;
-                  # in {
-                  #   inherit raw system;
-
-                  #   double = lib'.systems.into.double system;
-                  #   triple = lib'.systems.into.triple system;
-                  # };
-                  apply = raw: let
-                    system = lib'.systems.from.string raw;
-                    x = lib'.systems.withBuildInfo raw;
-                  in
-                    x;
                 };
               };
 
-              phases = lib.options.create {
+              host = {
-                description = "The phases for the package.";
+                only = lib.options.create {
-                type = lib.types.dag.of (lib.types.either lib.types.string (lib.types.function lib.types.string));
+                  description = "Dependencies which are only used in the host environment.";
-                default.value = {};
+                  type = lib'.types.dependencies host host host;
-              };
+                  default.value = {};
-
-              env = lib.options.create {
-                description = "The environment for the package.";
-                type = lib.types.attrs.of lib.types.string;
-                default.value = {};
-              };
-
-              builder = lib.options.create {
-                description = "The builder for the package.";
-                type = lib'.types.builder;
-              };
-
-              deps = {
-                build = {
-                  only = lib.options.create {
-                    description = "Dependencies which are only used in the build environment.";
-                    type = lib'.types.dependencies;
-                    default.value = {};
-                  };
-
-                  build = lib.options.create {
-                    description = "Dependencies which are created in the build environment and are executed in the build environment.";
-                    type = lib'.types.dependencies;
-                    default.value = {};
-                  };
-
-                  host = lib.options.create {
-                    description = "Dependencies which are created in the build environment and are executed in the host environment.";
-                    type = lib'.types.dependencies;
-                    default.value = {};
-                  };
-
-                  target = lib.options.create {
-                    description = "Dependencies which are created in the build environment and are executed in the target environment.";
-                    type = lib'.types.dependencies;
-                    default.value = {};
-                  };
                 };
 
-                host = {
+                host = lib.options.create {
-                  only = lib.options.create {
+                  description = "Dependencies which are executed in the host environment.";
-                    description = "Dependencies which are only used in the host environment.";
+                  type = lib'.types.dependencies host host target;
-                    type = lib'.types.dependencies;
+                  default.value = {};
-                    default.value = {};
-                  };
-
-                  host = lib.options.create {
-                    description = "Dependencies which are executed in the host environment.";
-                    type = lib'.types.dependencies;
-                    default.value = {};
-                  };
-
-                  target = lib.options.create {
-                    description = "Dependencies which are executed in the host environment which produces code for the target environment.";
-                    type = lib'.types.dependencies;
-                    default.value = {};
-                  };
                 };
 
-                target = {
+                target = lib.options.create {
-                  only = lib.options.create {
+                  description = "Dependencies which are executed in the host environment which produces code for the target environment.";
-                    description = "Dependencies which are only used in the target environment.";
+                  type = lib'.types.dependencies host target target;
-                    type = lib'.types.dependencies;
+                  default.value = {};
-                    default.value = {};
-                  };
-
-                  target = lib.options.create {
-                    description = "Dependencies which are executed in the target environment.";
-                    type = lib'.types.dependencies;
-                    default.value = {};
-                  };
                 };
               };
 
-              package = lib.options.create {
+              target = {
-                description = "The built derivation.";
+                only = lib.options.create {
-                type = lib.types.derivation;
+                  description = "Dependencies which are only used in the target environment.";
-                default.value = config.builder.build config;
+                  type = lib'.types.dependencies target target target;
+                  default.value = {};
+                };
+
+                target = lib.options.create {
+                  description = "Dependencies which are executed in the target environment.";
+                  type = lib'.types.dependencies target target target;
+                  default.value = {};
+                };
               };
             };
-          }
+          };
-        );
+        };
-      };
+
+        type =
+          (lib.types.coerceWithLocation initial transform final)
+          // {
+            name = "Package";
+            description = "a package definition";
+          };
+      in
+        type
+        // {
+          children =
+            type.children
+            // {
+              inherit submodule;
+            };
+        };
     };
   };
 }

tidepool/src/packages/aux/a.nix

@@ -12,6 +12,8 @@ in {
             platforms = ["i686-linux"];
           };
 
+          name = "${config.pname}-${config.version}";
+
           pname = "a";
           version = "1.0.0";
 

tidepool/src/packages/aux/b.nix

@@ -1,15 +1,12 @@
-{
+{config}: let
-  lib',
+  inherit (config) lib builders packages;
-  config,
-}: let
-  inherit (config) builders packages;
 in {
   config.packages.aux.b = {
     versions = {
       "latest" = {config}: {
         options = {
-          custom = lib'.options.create {
+          custom = lib.options.create {
-            type = lib'.types.bool;
+            type = lib.types.bool;
           };
         };
 
@@ -18,6 +15,8 @@ in {
             platforms = ["i686-linux"];
           };
 
+          name = "${config.pname}-${config.version}";
+
           custom = true;
 
           pname = "b";

tidepool/src/packages/default.nix

@@ -1,9 +1,7 @@
-{
+{config}: let
-  lib,
+  inherit (config) lib;
-  lib',
+
-  config,
+  doubles = lib.systems.doubles.all;
-}: let
-  doubles = lib'.systems.doubles.all;
 
   packages = builtins.removeAttrs config.packages ["cross"];
 in {
@@ -17,13 +15,13 @@ in {
     packages = lib.options.create {
       description = "The package set.";
       type = lib.types.submodule {
-        freeform = lib.types.attrs.of (lib.types.submodule {freeform = lib'.types.alias;});
+        freeform = lib.types.packages;
 
         options.cross = lib.attrs.generate doubles (
           system:
             lib.options.create {
               description = "The cross-compiled package set for the ${system} target.";
-              type = lib'.types.packages;
+              type = lib.types.packages;
               default = {};
             }
         );
@@ -49,38 +47,48 @@ in {
           builtins.mapAttrs (
             name: alias: let
               setHost = package:
-                if package != {}
+              package // {
-                then
+                __modules__ = package.__modules__ ++ [
-                  (package.extend (
+                  {
-                    {config}: {
+                    config.platform = {
-                      config = {
+                        host = lib.modules.override 5 system;
-                        platform = {
+                        target = lib.modules.override 5 system;
-                          host = lib.modules.overrides.force system;
+                    };
-                          target = lib.modules.overrides.default system;
+                  }
-                        };
+                ];
+              };
+              # if package != {}
+              # then
+              #   (package.extend (
+              #     {config}: {
+              #       config = {
+              #         platform = {
+              #           host = lib.modules.overrides.force system;
+              #           target = lib.modules.overrides.default system;
+              #         };
 
-                        deps = {
+              #         deps = {
-                          build = {
+              #           build = {
-                            only = setHost package.deps.build.only;
+              #             only = setHost package.deps.build.only;
-                            build = setHost package.deps.build.build;
+              #             build = setHost package.deps.build.build;
-                            host = setHost package.deps.build.host;
+              #             host = setHost package.deps.build.host;
-                            target = setHost package.deps.build.target;
+              #             target = setHost package.deps.build.target;
-                          };
+              #           };
-                          host = {
+              #           host = {
-                            only = setHost package.deps.host.only;
+              #             only = setHost package.deps.host.only;
-                            host = setHost package.deps.host.host;
+              #             host = setHost package.deps.host.host;
-                            target = setHost package.deps.host.target;
+              #             target = setHost package.deps.host.target;
-                          };
+              #           };
-                          target = {
+              #           target = {
-                            only = setHost package.deps.target.only;
+              #             only = setHost package.deps.target.only;
-                            target = setHost package.deps.target.target;
+              #             target = setHost package.deps.target.target;
-                          };
+              #           };
-                        };
+              #         };
-                      };
+              #       };
-                    }
+              #     }
-                  ))
+              #   ))
-                  .config
+              #   .config
-                else package;
+              # else package;
 
               updated =
                 alias

tidepool/src/packages/foundation/gcc/default.nix

@@ -1,236 +1,217 @@
 {
-  lib,
-  lib',
   config,
   options,
-}:
+}: let
-let
+  inherit
-  inherit (config)
+    (config)
+    lib
     mirrors
     builders
     # These are the upstream foundational packages exported from the Aux Foundation project.
-
+    
     foundation
+    packages
     ;
-in
+in {
-{
   config.packages.foundation.gcc = {
     versions = {
-      "latest" =
+      "latest" = {
-        { config, meta }:
+        config,
-        {
+        meta,
-          options = {
+      }: {
+        options = {
+          src = lib.options.create {
+            type = lib.types.derivation;
+            description = "Source for the package.";
+          };
+
+          cc = {
             src = lib.options.create {
               type = lib.types.derivation;
-              description = "Source for the package.";
+              description = "The cc source for the package.";
-            };
-
-            cc = {
-              src = lib.options.create {
-                type = lib.types.derivation;
-                description = "The cc source for the package.";
-              };
-            };
-
-            gmp = {
-              src = lib.options.create {
-                type = lib.types.derivation;
-                description = "The gmp source for the package.";
-              };
-
-              version = lib.options.create {
-                type = lib.types.string;
-                description = "Version of gmp.";
-              };
-            };
-
-            mpfr = {
-              src = lib.options.create {
-                type = lib.types.derivation;
-                description = "The mpfr source for the package.";
-              };
-
-              version = lib.options.create {
-                type = lib.types.string;
-                description = "Version of mpfr.";
-              };
-            };
-
-            mpc = {
-              src = lib.options.create {
-                type = lib.types.derivation;
-                description = "The mpc source for the package.";
-              };
-
-              version = lib.options.create {
-                type = lib.types.string;
-                description = "Version of mpc.";
-              };
-            };
-
-            isl = {
-              src = lib.options.create {
-                type = lib.types.derivation;
-                description = "The isl source for the package.";
-              };
-              version = lib.options.create {
-                type = lib.types.string;
-                description = "Version of isl.";
-              };
             };
           };
 
-          config = {
+          gmp = {
-            meta = {
+            src = lib.options.create {
-              platforms = [ "i686-linux" ];
+              type = lib.types.derivation;
+              description = "The gmp source for the package.";
             };
 
-            pname = "gcc";
+            version = lib.options.create {
-            version = "13.2.0";
+              type = lib.types.string;
+              description = "Version of gmp.";
+            };
+          };
 
-            builder = builders.basic;
+          mpfr = {
-
+            src = lib.options.create {
-            env = {
+              type = lib.types.derivation;
-              PATH =
+              description = "The mpfr source for the package.";
-                let
-                  gcc =
-                    if
-                      config.platform.build.triple == config.platform.host.triple
-                    # If we're on the same system then we can use the existing GCC instance.
-                    then
-                      foundation.stage2-gcc
-                    # Otherwise we are going to need a cross-compiler.
-                    else
-                      # TODO: Create a gcc-cross package.
-                      (meta.extend (args: {
-                        config = {
-                          platform = {
-                            build = config.platform.build.triple;
-                            host = config.platform.build.triple;
-                            target = lib.modules.override.force config.platform.host.triple;
-                          };
-                        };
-                      })).config.package;
-                in
-                lib.paths.bin [
-                  foundation.stage2-gcc
-                  foundation.stage2-binutils
-                  foundation.stage2-gnumake
-                  foundation.stage2-gnused
-                  foundation.stage2-gnugrep
-                  foundation.stage2-gawk
-                  foundation.stage2-diffutils
-                  foundation.stage2-findutils
-                  foundation.stage2-gnutar
-                  foundation.stage2-gzip
-                  foundation.stage2-bzip2
-                  foundation.stage1-xz
-                ];
             };
 
-            phases =
+            version = lib.options.create {
-              let
+              type = lib.types.string;
-                host = lib'.systems.withBuildInfo config.platform.host;
+              description = "Version of mpfr.";
+            };
+          };
 
-                mbits = if host.system.cpu.family == "x86" then if host.is64bit then "-m64" else "-m32" else "";
+          mpc = {
-              in
+            src = lib.options.create {
-              {
+              type = lib.types.derivation;
-                unpack = lib.dag.entry.before [ "patch" ] ''
+              description = "The mpc source for the package.";
-                  # Unpack
-                  tar xf ${config.src}
-                  tar xf ${config.gmp.src}
-                  tar xf ${config.mpfr.src}
-                  tar xf ${config.mpc.src}
-                  tar xf ${config.isl.src}
-                  cd gcc-${config.version}
-
-                  ln -s ../gmp-${config.gmp.version} gmp
-                  ln -s ../mpfr-${config.mpfr.version} mpfr
-                  ln -s ../mpc-${config.mpc.version} mpc
-                  ln -s ../isl-${config.isl.version} isl
-                '';
-
-                patch = lib.dag.entry.between [ "configure" ] [ "unpack" ] ''
-                  # Patch
-                  # force musl even if host triple is gnu
-                  sed -i 's|"os/gnu-linux"|"os/generic"|' libstdc++-v3/configure.host
-                '';
-
-                configure = lib.dag.entry.between [ "build" ] [ "patch" ] ''
-                  # Configure
-                  export CC="gcc -Wl,-dynamic-linker -march=${
-                    host.gcc.arch or host.system.cpu.family
-                  } ${mbits} -Wl,${foundation.stage1-musl}/lib/libc.so"
-                  export CXX="g++ -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
-                  export CFLAGS_FOR_TARGET="-Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
-                  export LIBRARY_PATH="${foundation.stage1-musl}/lib"
-
-                  bash ./configure \
-                    --prefix=$out \
-                    --build=${config.platform.build.triple} \
-                    --host=${config.platform.host.triple} \
-                    --target=${config.platform.target.triple} \
-                    --with-native-system-header-dir=/include \
-                    --with-sysroot=${foundation.stage1-musl} \
-                    --enable-languages=c,c++ \
-                    --disable-bootstrap \
-                    --disable-libsanitizer \
-                    --disable-lto \
-                    --disable-multilib \
-                    --disable-plugin \
-                    CFLAGS=-static \
-                    CXXFLAGS=-static
-                '';
-
-                build = lib.dag.entry.between [ "install" ] [ "configure" ] ''
-                  # Build
-                  make -j $NIX_BUILD_CORES
-                '';
-
-                install = lib.dag.entry.after [ "build" ] ''
-                  # Install
-                  make -j $NIX_BUILD_CORES install-strip
-                '';
-              };
-
-            src = builtins.fetchurl {
-              url = "${mirrors.gnu}/gcc/gcc-${config.version}/gcc-${config.version}.tar.xz";
-              sha256 = "4nXnZEKmBnNBon8Exca4PYYTFEAEwEE1KIY9xrXHQ9o=";
             };
 
-            gmp = {
+            version = lib.options.create {
-              version = "6.3.0";
+              type = lib.types.string;
-              src = builtins.fetchurl {
+              description = "Version of mpc.";
-                url = "${mirrors.gnu}/gmp/gmp-${config.gmp.version}.tar.xz";
-                sha256 = "o8K4AgG4nmhhb0rTC8Zq7kknw85Q4zkpyoGdXENTiJg=";
-              };
             };
+          };
 
-            mpfr = {
+          isl = {
-              version = "4.2.1";
+            src = lib.options.create {
-              src = builtins.fetchurl {
+              type = lib.types.derivation;
-                url = "${mirrors.gnu}/mpfr/mpfr-${config.mpfr.version}.tar.xz";
+              description = "The isl source for the package.";
-                sha256 = "J3gHNTpnJpeJlpRa8T5Sgp46vXqaW3+yeTiU4Y8fy7I=";
-              };
             };
-
+            version = lib.options.create {
-            mpc = {
+              type = lib.types.string;
-              version = "1.3.1";
+              description = "Version of isl.";
-              src = builtins.fetchurl {
-                url = "${mirrors.gnu}/mpc/mpc-${config.mpc.version}.tar.gz";
-                sha256 = "q2QkkvXPiCt0qgy3MM1BCoHtzb7IlRg86TDnBsHHWbg=";
-              };
-            };
-
-            isl = {
-              version = "0.24";
-              src = builtins.fetchurl {
-                url = "https://gcc.gnu.org/pub/gcc/infrastructure/isl-${config.isl.version}.tar.bz2";
-                sha256 = "/PeN2WVsEOuM+fvV9ZoLawE4YgX+GTSzsoegoYmBRcA=";
-              };
             };
           };
         };
+
+        config = {
+          meta = {
+            platforms = ["i686-linux"];
+          };
+
+          pname = "gcc";
+          version = "13.2.0";
+
+          builder = builders.basic;
+
+          env = {
+            PATH = lib.paths.bin [
+              foundation.stage2-gcc
+              foundation.stage2-binutils
+              foundation.stage2-gnumake
+              foundation.stage2-gnused
+              foundation.stage2-gnugrep
+              foundation.stage2-gawk
+              foundation.stage2-diffutils
+              foundation.stage2-findutils
+              foundation.stage2-gnutar
+              foundation.stage2-gzip
+              foundation.stage2-bzip2
+              foundation.stage1-xz
+            ];
+          };
+
+          phases = let
+            host = lib.systems.withBuildInfo config.platform.host;
+
+            mbits =
+              if host.system.cpu.family == "x86"
+              then
+                if host.is64bit
+                then "-m64"
+                else "-m32"
+              else "";
+          in {
+            unpack = lib.dag.entry.before ["patch"] ''
+              # Unpack
+              tar xf ${config.src}
+              tar xf ${config.gmp.src}
+              tar xf ${config.mpfr.src}
+              tar xf ${config.mpc.src}
+              tar xf ${config.isl.src}
+              cd gcc-${config.version}
+
+              ln -s ../gmp-${config.gmp.version} gmp
+              ln -s ../mpfr-${config.mpfr.version} mpfr
+              ln -s ../mpc-${config.mpc.version} mpc
+              ln -s ../isl-${config.isl.version} isl
+            '';
+
+            patch = lib.dag.entry.between ["configure"] ["unpack"] ''
+              # Patch
+              # force musl even if host triple is gnu
+              sed -i 's|"os/gnu-linux"|"os/generic"|' libstdc++-v3/configure.host
+            '';
+
+            configure = lib.dag.entry.between ["build"] ["patch"] ''
+              # Configure
+              export CC="gcc -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
+              export CXX="g++ -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
+              export CFLAGS_FOR_TARGET="-Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
+              export LIBRARY_PATH="${foundation.stage1-musl}/lib"
+
+              bash ./configure \
+                --prefix=$out \
+                --build=${config.platform.build.triple} \
+                --host=${config.platform.host.triple} \
+                --target=${config.platform.target.triple} \
+                --with-native-system-header-dir=/include \
+                --with-sysroot=${foundation.stage1-musl} \
+                --enable-languages=c,c++ \
+                --disable-bootstrap \
+                --disable-libsanitizer \
+                --disable-lto \
+                --disable-multilib \
+                --disable-plugin \
+                CFLAGS=-static \
+                CXXFLAGS=-static
+            '';
+
+            build = lib.dag.entry.between ["install"] ["configure"] ''
+              # Build
+              make -j $NIX_BUILD_CORES
+            '';
+
+            install = lib.dag.entry.after ["build"] ''
+              # Install
+              make -j $NIX_BUILD_CORES install-strip
+            '';
+          };
+
+          src = builtins.fetchurl {
+            url = "${mirrors.gnu}/gcc/gcc-${config.version}/gcc-${config.version}.tar.xz";
+            sha256 = "4nXnZEKmBnNBon8Exca4PYYTFEAEwEE1KIY9xrXHQ9o=";
+          };
+
+          gmp = {
+            version = "6.3.0";
+            src = builtins.fetchurl {
+              url = "${mirrors.gnu}/gmp/gmp-${config.gmp.version}.tar.xz";
+              sha256 = "o8K4AgG4nmhhb0rTC8Zq7kknw85Q4zkpyoGdXENTiJg=";
+            };
+          };
+
+          mpfr = {
+            version = "4.2.1";
+            src = builtins.fetchurl {
+              url = "${mirrors.gnu}/mpfr/mpfr-${config.mpfr.version}.tar.xz";
+              sha256 = "J3gHNTpnJpeJlpRa8T5Sgp46vXqaW3+yeTiU4Y8fy7I=";
+            };
+          };
+
+          mpc = {
+            version = "1.3.1";
+            src = builtins.fetchurl {
+              url = "${mirrors.gnu}/mpc/mpc-${config.mpc.version}.tar.gz";
+              sha256 = "q2QkkvXPiCt0qgy3MM1BCoHtzb7IlRg86TDnBsHHWbg=";
+            };
+          };
+
+          isl = {
+            version = "0.24";
+            src = builtins.fetchurl {
+              url = "https://gcc.gnu.org/pub/gcc/infrastructure/isl-${config.isl.version}.tar.bz2";
+              sha256 = "/PeN2WVsEOuM+fvV9ZoLawE4YgX+GTSzsoegoYmBRcA=";
+            };
+          };
+        };
+      };
     };
   };
 }