···

       
178
       
178
       
 
       
Alternatively, you can specify other derivations as tests. You can make use of

     

       
179
       
179
       
 
       
the optional parameter to inject the correct package without

     

       
180
       
180
       
 
       
relying on non-local definitions, even in the presence of `overrideAttrs`.

     

       
181
       
181
       
-
       
Here that's `finalAttrs.public`, but you could choose a different name if

     

       
181
       
181
       
+
       
Here that's `finalAttrs.finalPackage`, but you could choose a different name if

     

       
182
       
182
       
 
       
`finalAttrs` already exists in your scope.

     

       
183
       
183
       
 
       


     

       
184
       
184
       
 
       
`(mypkg.overrideAttrs f).passthru.tests` will be as expected, as long as the

     
···

       
190
       
190
       
 
       
{ stdenv, callPackage }:

     

       
191
       
191
       
 
       
stdenv.mkDerivation (finalAttrs: {

     

       
192
       
192
       
 
       
  # ...

     

       
193
       
193
       
-
       
  passthru.tests.example = callPackage ./example.nix { my-package = finalAttrs.public; }

     

       
193
       
193
       
+
       
  passthru.tests.example = callPackage ./example.nix { my-package = finalAttrs.finalPackage; };

     

       
194
       
194
       
 
       
})

     

       
195
       
195
       
 
       
```

     

       
196
       
196
       
 
       


     

···

       
336
       
336
       
 
       
Instead, the definition references `finalAttrs`, allowing users to change `withFeature`

     

       
337
       
337
       
 
       
consistently with `overrideAttrs`.

     

       
338
       
338
       
 
       


     

       
339
       
339
       
-
       
`finalAttrs` also contains the attribute `public`, which represents the final package,

     

       
340
       
340
       
-
       
including the output paths, etc.

     

       
339
       
339
       
+
       
`finalAttrs` also contains the attribute `finalPackage`, which includes the output paths, etc.

     

       
341
       
340
       
 
       


     

       
342
       
341
       
 
       
Let's look at a more elaborate example to understand the differences between

     

       
343
       
342
       
 
       
various bindings:

     
···

       
352
       
351
       
 
       
    packages = [];

     

       
353
       
352
       
 
       


     

       
354
       
353
       
 
       
    # `passthru.tests` is a commonly defined attribute.

     

       
355
       
355
       
-
       
    passthru.tests.simple = f finalAttrs.public;

     

       
354
       
354
       
+
       
    passthru.tests.simple = f finalAttrs.finalPackage;

     

       
356
       
355
       
 
       


     

       
357
       
356
       
 
       
    # An example of an attribute containing a function

     

       
358
       
357
       
 
       
    passthru.appendPackages = packages':

     

       
359
       
359
       
-
       
      finalAttrs.public.overrideAttrs (newSelf: super: {

     

       
358
       
358
       
+
       
      finalAttrs.finalPackage.overrideAttrs (newSelf: super: {

     

       
360
       
359
       
 
       
        packages = super.packages ++ packages';

     

       
361
       
360
       
 
       
      });

     

       
362
       
361
       
 
       


     
···

       
368
       
367
       
 
       
in pkg

     

       
369
       
368
       
 
       
```

     

       
370
       
369
       
 
       


     

       
371
       
371
       
-
       
Unlike the `pkg` binding in the above example, the `finalAttrs` parameter always references the final attributes. For instance `(pkg.overrideAttrs(x)).finalAttrs.public` is identical to `pkg.overrideAttrs(x)`, whereas `(pkg.overrideAttrs(x)).original` is the same as the original `pkg`.

     

       
370
       
370
       
+
       
Unlike the `pkg` binding in the above example, the `finalAttrs` parameter always references the final attributes. For instance `(pkg.overrideAttrs(x)).finalAttrs.finalPackage` is identical to `pkg.overrideAttrs(x)`, whereas `(pkg.overrideAttrs(x)).original` is the same as the original `pkg`.

     

       
372
       
371
       
 
       


     

       
373
       
372
       
 
       
See also the section about [`passthru.tests`](#var-meta-tests).

     

       
374
       
373
       
 
       


     

···

       
48
       
48
       
 
       


     

       
49
       
49
       
 
       
The argument `previousAttrs` is conventionally used to refer to the attr set originally passed to `stdenv.mkDerivation`.

     

       
50
       
50
       
 
       


     

       
51
       
51
       
-
       
The argument `finalAttrs` refers to the final attributes passed to `mkDerivation`, plus the `public` attribute which is the result of `mkDerivation` — the derivation or package.

     

       
51
       
51
       
+
       
The argument `finalAttrs` refers to the final attributes passed to `mkDerivation`, plus the `finalPackage` attribute which is equal to the result of `mkDerivation` or subsequent `overrideAttrs` calls.

     

       
52
       
52
       
 
       


     

       
53
       
53
       
 
       
If only a one-argument function is written, the argument has the meaning of `previousAttrs`.

     

       
54
       
54
       
 
       


     

···

       
57
       
57
       
 
       
        </para>

     

       
58
       
58
       
 
       
        <para>

     

       
59
       
59
       
 
       
          Additionally, <literal>passthru</literal> can now reference

     

       
60
       
60
       
-
       
          <literal>finalAttrs.public</literal> containing the final

     

       
61
       
61
       
-
       
          package, including attributes such as the output paths and

     

       
62
       
62
       
-
       
          <literal>overrideAttrs</literal>.

     

       
60
       
60
       
+
       
          <literal>finalAttrs.finalPackage</literal> containing the

     

       
61
       
61
       
+
       
          final package, including attributes such as the output paths

     

       
62
       
62
       
+
       
          and <literal>overrideAttrs</literal>.

     

       
63
       
63
       
 
       
        </para>

     

       
64
       
64
       
 
       
        <para>

     

       
65
       
65
       
 
       
          New language integrations can be simplified by overriding a

     

···

       
23
       
23
       
 
       
  This allows packaging configuration to be overridden in a consistent manner by

     

       
24
       
24
       
 
       
  providing an alternative to `rec {}` syntax.

     

       
25
       
25
       
 
       


     

       
26
       
26
       
-
       
  Additionally, `passthru` can now reference `finalAttrs.public` containing

     

       
26
       
26
       
+
       
  Additionally, `passthru` can now reference `finalAttrs.finalPackage` containing

     

       
27
       
27
       
 
       
  the final package, including attributes such as the output paths and

     

       
28
       
28
       
 
       
  `overrideAttrs`.

     

       
29
       
29
       
 
       


     

···

       
28
       
28
       
 
       
        (nixos { environment.noXlibs = true; }).pkgs.hello;

     

       
29
       
29
       
 
       
  };

     

       
30
       
30
       
 
       


     

       
31
       
31
       
-
       
  passthru.tests.run = callPackage ./test.nix { hello = finalAttrs.public; };

     

       
31
       
31
       
+
       
  passthru.tests.run = callPackage ./test.nix { hello = finalAttrs.finalPackage; };

     

       
32
       
32
       
 
       


     

       
33
       
33
       
 
       
  meta = with lib; {

     

       
34
       
34
       
 
       
    description = "A program that produces a familiar, friendly greeting";

     

···

       
24
       
24
       
 
       
      # separate lines, because Nix would only show the last line of the comment.

     

       
25
       
25
       
 
       


     

       
26
       
26
       
 
       
      # An infinite recursion here can be caused by having the attribute names of expression `e` in `.overrideAttrs(finalAttrs: previousAttrs: e)` depend on `finalAttrs`. Only the attribute values of `e` can depend on `finalAttrs`.

     

       
27
       
27
       
-
       
      args = rattrs (args // { inherit public; });

     

       
27
       
27
       
+
       
      args = rattrs (args // { inherit finalPackage; });

     

       
28
       
28
       
 
       
      #              ^^^^

     

       
29
       
29
       
 
       


     

       
30
       
30
       
-
       
      public =

     

       
30
       
30
       
+
       
      finalPackage =

     

       
31
       
31
       
 
       
        mkDerivationSimple

     

       
32
       
32
       
 
       
          (f0:

     

       
33
       
33
       
 
       
            let

     
···

       
51
       
51
       
 
       
              makeDerivationExtensible mkDerivationSimple

     

       
52
       
52
       
 
       
                (self: let super = rattrs self; in super // f self super))

     

       
53
       
53
       
 
       
          args;

     

       
54
       
54
       
-
       
    in public;

     

       
54
       
54
       
+
       
    in finalPackage;

     

       
55
       
55
       
 
       


     

       
56
       
56
       
 
       
  # makeDerivationExtensibleConst == makeDerivationExtensible (_: attrs),

     

       
57
       
57
       
 
       
  # but pre-evaluated for a slight improvement in performance.