Merge pull request #292209 from hercules-ci/lazyDerivation-multi-output

{ lib }:

let

  inherit (lib) throwIfNot;

  inherit (lib)

    genAttrs

    isString

    throwIfNot

    ;

  showMaybeAttrPosPre = prefix: attrName: v:

    let pos = builtins.unsafeGetAttrPos attrName v;

    in if pos == null then "" else "${prefix}${pos.file}:${toString pos.line}:${toString pos.column}";

  showMaybePackagePosPre = prefix: pkg:

    if pkg?meta.position && isString pkg.meta.position

    then "${prefix}${pkg.meta.position}"

    else "";

in

{

  /*

      #

      # This can be used for adding package attributes, such as `tests`.

      passthru ? { }

    , # Optional list of assumed outputs. Default: ["out"]

      #

      # This must match the set of outputs that the returned derivation has.

      # You must use this when the derivation has multiple outputs.

      outputs ? [ "out" ]

    }:

    let

      # These checks are strict in `drv` and some `drv` attributes, but the

      # Instead, the individual derivation attributes do depend on it.

      checked =

        throwIfNot (derivation.type or null == "derivation")

          "lazySimpleDerivation: input must be a derivation."

          "lazyDerivation: input must be a derivation."

          throwIfNot

          (derivation.outputs == [ "out" ])

          # Supporting multiple outputs should be a matter of inheriting more attrs.

          "The derivation ${derivation.name or "<unknown>"} has multiple outputs. This is not supported by lazySimpleDerivation yet. Support could be added, and be useful as long as the set of outputs is known in advance, without evaluating the actual derivation."

          # NOTE: Technically we could require our outputs to be a subset of the

          # actual ones, or even leave them unchecked and fail on a lazy basis.

          # However, consider the case where an output is added in the underlying

          # derivation, such as dev. lazyDerivation would remove it and cause it

          # to fail as a buildInputs item, without any indication as to what

          # happened. Hence the more stringent condition. We could consider

          # adding a flag to control this behavior if there's a valid case for it,

          # but the documentation must have a note like this.

          (derivation.outputs == outputs)

          ''

            lib.lazyDerivation: The derivation ${derivation.name or "<unknown>"} has outputs that don't match the assumed outputs.

            Assumed outputs passed to lazyDerivation${showMaybeAttrPosPre ",\n    at " "outputs" args}:

                ${lib.generators.toPretty { multiline = false; } outputs};

            Actual outputs of the derivation${showMaybePackagePosPre ",\n    defined at " derivation}:

                ${lib.generators.toPretty { multiline = false; } derivation.outputs}

            If the outputs are known ahead of evaluating the derivation,

            then update the lazyDerivation call to match the actual outputs, in the same order.

            If lazyDerivation is passed a literal value, just change it to the actual outputs.

            As a result it will work as before / as intended.

            Otherwise, when the outputs are dynamic and can't be known ahead of time, it won't

            be possible to add laziness, but lib.lazyDerivation may still be useful for trimming

            the attributes.

            If you want to keep trimming the attributes, make sure that the package is in a

            variable (don't evaluate it twice!) and pass the variable and its outputs attribute

            to lib.lazyDerivation. This largely defeats laziness, but keeps the trimming.

            If none of the above works for you, replace the lib.lazyDerivation call by the

            expression in the derivation argument.

          ''

          derivation;

    in

    {

      # A fixed set of derivation values, so that `lazyDerivation` can return

      # its attrset before evaluating `derivation`.

      # This must only list attributes that are available on _all_ derivations.

      inherit (checked) outputs out outPath outputName drvPath name system;

      inherit (checked) outPath outputName drvPath name system;

      inherit outputs;

      # The meta attribute can either be taken from the derivation, or if the

      # `lazyDerivation` caller knew a shortcut, be taken from there.

      meta = args.meta or checked.meta;

    } // passthru;

    }

    // genAttrs outputs (outputName: checked.${outputName})

    // passthru;

  /* Conditionally set a derivation attribute.

    }).drvPath;

  };

  testLazyDerivationMultiOutputReturnsDerivationAttrs = let

    derivation = {

      type = "derivation";

      outputs = ["out" "dev"];

      dev = "test dev";

      out = "test out";

      outPath = "test outPath";

      outputName = "out";

      drvPath = "test drvPath";

      name = "test name";

      system = "test system";

      meta.position = "/hi:23";

    };

  in {

    expr = lazyDerivation { inherit derivation; outputs = ["out" "dev"]; passthru.meta.position = "/hi:23"; };

    expected = derivation;

  };

  testTypeDescriptionInt = {

    expr = (with types; int).description;

    expected = "signed integer";