Merge pull request #43863 from volth/unused4

[bot] nixos/*: remove unused arguments in lambdas

nixos/lib/build-vms.nix

···
       machinesNumbered = zipLists machines (range 1 254);
 
       nodes_ = flip map machinesNumbered (m: nameValuePair m.fst
-        [ ( { config, pkgs, nodes, ... }:
+        [ ( { config, nodes, ... }:
             let
               interfacesNumbered = zipLists config.virtualisation.vlans (range 1 255);
               interfaces = flip map interfacesNumbered ({ fst, snd }:

nixos/lib/make-disk-image.nix

···
   #   most likely fails as GRUB will probably refuse to install.
   partitionTableType ? "legacy"
 
-  # Whether to invoke switch-to-configuration boot during image creation
-, installBootLoader ? true
-
 , # The root file system type.
   fsType ? "ext4"
 

nixos/lib/make-iso9660-image.nix

···
-{ stdenv, perl, closureInfo, xorriso, syslinux
+{ stdenv, closureInfo, xorriso, syslinux
 
 , # The file name of the resulting ISO image.
   isoName ? "cd.iso"

nixos/lib/testing.nix

···
   runInMachineWithX = { require ? [], ... } @ args:
     let
       client =
-        { config, pkgs, ... }:
+        { ... }:
         {
           inherit require;
           virtualisation.memorySize = 1024;

nixos/maintainers/option-usages.nix

···
          else testOptions;
        checkAll = checkList == [];
      in
-       flip filter graph ({option, usedBy}:
+       flip filter graph ({option, ...}:
          (checkAll || elem option checkList)
          && !(elem option excludedTestOptions)
        );
···
   '';
 
   graphToText = graph:
-    concatMapStrings ({option, usedBy}:
+    concatMapStrings ({usedBy, ...}:
         concatMapStrings (user: ''
           ${user}
         '') usedBy

nixos/modules/config/no-x-libs.nix

···
 # This module gets rid of all dependencies on X11 client libraries
 # (including fontconfig).
 
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/config/nsswitch.nix

···
 # Configuration for the Name Service Switch (/etc/nsswitch.conf).
 
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/config/power-management.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/config/sysctl.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/config/unix-odbc-drivers.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/config/users-groups.nix

···
 
   };
 
-  groupOpts = { name, config, ... }: {
+  groupOpts = { name, ... }: {
 
     options = {
 

nixos/modules/config/vpnc.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/hardware/network/smc-2632w/default.nix

···
-{lib, config, ...}:
+{lib, ...}:
 
 {
   hardware = {

nixos/modules/hardware/network/zydas-zd1211.nix

···
-{pkgs, config, ...}:
+{pkgs, ...}:
 
 {
   hardware.firmware = [ pkgs.zd1211fw ];

nixos/modules/hardware/video/ati.nix

···
 # This module provides the proprietary ATI X11 / OpenGL drivers.
 
-{ config, lib, pkgs, pkgs_i686, ... }:
+{ config, lib, pkgs_i686, ... }:
 
 with lib;
 

nixos/modules/hardware/video/capture/mwprocapture.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/hardware/video/uvcvideo/uvcdynctrl-udev-rules.nix

···
-{ lib
-, stdenv
-, buildEnv
+{ buildEnv
 , libwebcam
 , makeWrapper
 , runCommand

nixos/modules/installer/cd-dvd/installation-cd-graphical-kde-new-kernel.nix

···
-{ config, pkgs, ... }:
+{ pkgs, ... }:
 
 {
   imports = [ ./installation-cd-graphical-kde.nix ];

nixos/modules/installer/cd-dvd/installation-cd-minimal-new-kernel.nix

···
-{ config, pkgs, ... }:
+{ pkgs, ... }:
 
 {
   imports = [ ./installation-cd-minimal.nix ];

nixos/modules/installer/cd-dvd/installation-cd-minimal.nix

···
 # This module defines a small NixOS installation CD.  It does not
 # contain any graphical stuff.
 
-{ config, lib, pkgs, ... }:
+{ ... }:
 
 {
   imports =

nixos/modules/installer/netboot/netboot-base.nix

···
 # This module contains the basic configuration for building netboot
 # images
 
-{ config, lib, pkgs, ... }:
+{ lib, ... }:
 
 with lib;
 

nixos/modules/installer/netboot/netboot-minimal.nix

···
 # This module defines a small netboot environment.
 
-{ config, lib, ... }:
+{ ... }:
 
 {
   imports =

nixos/modules/installer/scan/detected.nix

···
 # List all devices which are detected by nixos-generate-config.
 # Common devices are enabled by default.
-{ config, lib, pkgs, ... }:
+{ lib, ... }:
 
 with lib;
 

nixos/modules/installer/tools/tools.nix

···
 # This module generates nixos-install, nixos-rebuild,
 # nixos-generate-config, etc.
 
-{ config, lib, pkgs, modulesPath, ... }:
+{ config, lib, pkgs, ... }:
 
 with lib;
 

nixos/modules/installer/virtualbox-demo.nix

···
-{ config, lib, pkgs, ... }:
+{ lib, ... }:
 
 with lib;
 

nixos/modules/misc/assertions.nix

···
-{ config, lib, pkgs, ... }:
+{ lib, ... }:
 
 with lib;
 

nixos/modules/misc/extra-arguments.nix

···
-{ lib, pkgs, config, ... }:
+{ pkgs, ... }:
 
 {
   _module.args = {

nixos/modules/misc/ids.nix

···
 # Systemd can also change ownership of service directories using the
 # RuntimeDirectory/StateDirectory options.
 
-{ config, pkgs, lib, ... }:
+{ lib, ... }:
 
 {
   options = {

nixos/modules/misc/label.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/misc/lib.nix

···
-{ config, lib, ... }:
+{ lib, ... }:
 
 {
   options = {

nixos/modules/misc/locate.nix

···
-{ config, options, lib, pkgs, ... }:
+{ config, lib, pkgs, ... }:
 
 with lib;
 

nixos/modules/misc/meta.nix

···
-{ config, lib, ... }:
+{ lib, ... }:
 
 with lib;
 

nixos/modules/misc/passthru.nix

···
 # This module allows you to export something from configuration
 # Use case: export kernel source expression for ease of configuring
 
-{ config, lib, ... }:
+{ lib, ... }:
 
 {
   options = {

nixos/modules/profiles/all-hardware.nix

···
 # enabled in the initrd.  Its primary use is in the NixOS installation
 # CDs.
 
-{ config, pkgs, ... }:
+{ ... }:
 
 {
 

nixos/modules/profiles/base.nix

···
 # This module defines the software packages included in the "minimal"
 # installation CD.  It might be useful elsewhere.
 
-{ config, lib, pkgs, ... }:
+{ lib, pkgs, ... }:
 
 {
   # Include some utilities that are useful for installing or repairing

nixos/modules/profiles/demo.nix

···
-{ config, pkgs, ... }:
+{ ... }:
 
 {
   imports = [ ./graphical.nix ];

nixos/modules/profiles/graphical.nix

···
 # This module defines a NixOS configuration with the Plasma 5 desktop.
 # It's used by the graphical installation CD.
 
-{ config, pkgs, ... }:
+{ pkgs, ... }:
 
 {
   services.xserver = {

nixos/modules/profiles/hardened.nix

···
 # A profile with most (vanilla) hardening options enabled by default,
 # potentially at the cost of features and performance.
 
-{ config, lib, pkgs, ... }:
+{ lib, pkgs, ... }:
 
 with lib;
 

nixos/modules/profiles/headless.nix

···
 # Common configuration for headless machines (e.g., Amazon EC2
 # instances).
 
-{ config, lib, pkgs, ... }:
+{ lib, ... }:
 
 with lib;
 

nixos/modules/profiles/minimal.nix

···
 # This module defines a small NixOS configuration.  It does not
 # contain any graphical stuff.
 
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/profiles/qemu-guest.nix

···
 # Common configuration for virtual machines running under QEMU (using
 # virtio).
 
-{ config, pkgs, ... }:
+{ ... }:
 
 {
   boot.initrd.availableKernelModules = [ "virtio_net" "virtio_pci" "virtio_mmio" "virtio_blk" "virtio_scsi" "9p" "9pnet_virtio" ];

nixos/modules/programs/atop.nix

···
 # Global configuration for atop.
 
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/programs/bcc.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 {
   options.programs.bcc.enable = lib.mkEnableOption "bcc";
 

nixos/modules/programs/environment.nix

···
 
 # Most of the stuff here should probably be moved elsewhere sometime.
 
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/programs/shell.nix

···
 # This module defines a standard configuration for NixOS shells.
 
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/programs/systemtap.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/security/hidepid.nix

···
-{ config, pkgs, lib, ... }:
+{ config, lib, ... }:
 with lib;
 
 {

nixos/modules/security/oath.nix

···
 # This module provides configuration for the OATH PAM modules.
 
-{ config, lib, pkgs, ... }:
+{ lib, ... }:
 
 with lib;
 

nixos/modules/services/backup/bacula.nix

···
     ${dir_cfg.extraConfig}
     '';
 
-  directorOptions = {name, config, ...}:
+  directorOptions = {...}:
   {
     options = {
       password = mkOption {
···
     };
   };
 
-  deviceOptions = {name, config, ...}:
+  deviceOptions = {...}:
   {
     options = {
       archiveDevice = mkOption {

nixos/modules/services/backup/borgbackup.nix

···
     '';
     default = { };
     type = types.attrsOf (types.submodule (
-      { name, config, ... }: {
+      { ... }: {
         options = {
           
           path = mkOption {

nixos/modules/services/backup/restic.nix

···
     description = ''
       Periodic backups to create with Restic.
     '';
-    type = types.attrsOf (types.submodule ({ name, config, ... }: {
+    type = types.attrsOf (types.submodule ({ name, ... }: {
       options = {
         passwordFile = mkOption {
           type = types.str;

nixos/modules/services/continuous-integration/jenkins/slave.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 with lib;
 let
   cfg = config.services.jenkinsSlave;

nixos/modules/services/hardware/actkbd.nix

···
     ${cfg.extraConfig}
   '';
 
-  bindingCfg = { config, ... }: {
+  bindingCfg = { ... }: {
     options = {
 
       keys = mkOption {

nixos/modules/services/hardware/nvidia-optimus.nix

···
-{ config, pkgs, lib, ... }:
+{ config, lib, ... }:
 
 let kernel = config.boot.kernelPackages; in
 

nixos/modules/services/hardware/sane_extra_backends/brscan4.nix

···
 
   etcFiles = pkgs.callPackage ./brscan4_etc_files.nix { netDevices = netDeviceList; };
 
-  netDeviceOpts = { name, config, ... }: {
+  netDeviceOpts = { name, ... }: {
 
     options = {
 

nixos/modules/services/logging/journalwatch.nix

···
-{ config, lib, pkgs, services, ... }:
+{ config, lib, pkgs, ... }:
 with lib;
 
 let

nixos/modules/services/mail/dovecot.nix

···
       special_use = \${toString mailbox.specialUse}
   '' + "}";
 
-  mailboxes = { lib, pkgs, ... }: {
+  mailboxes = { ... }: {
     options = {
       name = mkOption {
         type = types.strMatching ''[^"]+'';

nixos/modules/services/mail/mail.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/services/misc/emby.nix

···
-{ config, pkgs, lib, mono, ... }:
+{ config, pkgs, lib, ... }:
 
 with lib;
 

nixos/modules/services/misc/jackett.nix

···
-{ config, pkgs, lib, mono, ... }:
+{ config, pkgs, lib, ... }:
 
 with lib;
 

nixos/modules/services/misc/nix-gc.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/services/misc/nix-optimise.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/services/misc/nix-ssh-serve.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 let cfg = config.nix.sshServe;

nixos/modules/services/misc/radarr.nix

···
-{ config, pkgs, lib, mono, ... }:
+{ config, pkgs, lib, ... }:
 
 with lib;
 

nixos/modules/services/misc/sonarr.nix

···
-{ config, pkgs, lib, mono, ... }:
+{ config, pkgs, lib, ... }:
 
 with lib;
 

nixos/modules/services/misc/taskserver/default.nix

···
     in flatten (mapAttrsToList mkSublist attrs);
   in all isNull (findPkiDefinitions [] manualPkiOptions);
 
-  orgOptions = { name, ... }: {
+  orgOptions = { ... }: {
     options.users = mkOption {
       type = types.uniq (types.listOf types.str);
       default = [];

nixos/modules/services/monitoring/prometheus/exporters.nix

···
     };
   });
 
-  mkSubModule = { name, port, extraOpts, serviceOpts }: {
+  mkSubModule = { name, port, extraOpts, ... }: {
     ${name} = mkOption {
       type = types.submodule {
         options = (mkExporterOpts {

nixos/modules/services/monitoring/smartd.nix

···
        "DEVICESCAN ${notifyOpts}${cfg.defaults.autodetected}"}
   '';
 
-  smartdDeviceOpts = { name, ... }: {
+  smartdDeviceOpts = { ... }: {
 
     options = {
 

nixos/modules/services/network-filesystems/beegfs.nix

···
       description = ''
         BeeGFS configurations. Every mount point requires a separate configuration.
       '';
-      type = with types; attrsOf (submodule ({ config, ... } : {
+      type = with types; attrsOf (submodule ({ ... } : {
         options = {
           mgmtdHost = mkOption {
             type = types.str;

nixos/modules/services/network-filesystems/openafs/lib.nix

···
-{ config, lib, pkgs, ...}:
+{ config, lib, ...}:
 
 let
   inherit (lib) concatStringsSep mkOption types;

nixos/modules/services/networking/avahi-daemon.nix

···
 # Avahi daemon.
-{ config, lib, utils, pkgs, ... }:
+{ config, lib, pkgs, ... }:
 
 with lib;
 

nixos/modules/services/networking/cjdns.nix

···
   cfg = config.services.cjdns;
 
   connectToSubmodule =
-  { options, ... }:
+  { ... }:
   { options =
     { password = mkOption {
       type = types.str;

nixos/modules/services/networking/i2pd.nix

···
       outTunnels = mkOption {
         default = {};
         type = with types; loaOf (submodule (
-          { name, config, ... }: {
+          { name, ... }: {
             options = {
               destinationPort = mkOption {
                 type = types.int;
···
       inTunnels = mkOption {
         default = {};
         type = with types; loaOf (submodule (
-          { name, config, ... }: {
+          { name, ... }: {
             options = {
               inPort = mkOption {
                 type = types.int;

nixos/modules/services/networking/nghttpx/nghttpx-options.nix

···
-{ config, lib, ... }:
+{ lib, ... }:
 { options.services.nghttpx = {
     enable = lib.mkEnableOption "nghttpx";
 

nixos/modules/services/networking/nylon.nix

···
     Deny-IP=${concatStringsSep " " cfg.deniedIPRanges}
   '';
 
-  nylonOpts = { name, config, ... }: {
+  nylonOpts = { name, ... }: {
 
     options = {
 

nixos/modules/services/networking/pptpd.nix

···
-{ config, stdenv, pkgs, lib, ... }:
+{ config, pkgs, lib, ... }:
 
 with lib;
 

nixos/modules/services/networking/shout.nix

···
-{ pkgs, lib, config, options, ... }:
+{ pkgs, lib, config, ... }:
 
 with lib;
 

nixos/modules/services/networking/ssh/sshd.nix

···
 
     assertions = [{ assertion = if cfg.forwardX11 then cfgc.setXAuthLocation else true;
                     message = "cannot enable X11 forwarding without setting xauth location";}]
-      ++ flip map cfg.listenAddresses ({ addr, port, ... }: {
+      ++ flip map cfg.listenAddresses ({ addr, ... }: {
         assertion = addr != null;
         message = "addr must be specified in each listenAddresses entry";
       });

nixos/modules/services/networking/toxvpn.nix

···
-{ config, stdenv, pkgs, lib, ... }:
+{ config, pkgs, lib, ... }:
 
 with lib;
 

nixos/modules/services/networking/tvheadend.nix

···
-{ config, coreutils, lib, pkgs, ... }:
+{ config, lib, pkgs, ... }:
 
 with lib;
 

nixos/modules/services/networking/wireguard.nix

···
 
   # interface options
 
-  interfaceOpts = { name, ... }: {
+  interfaceOpts = { ... }: {
 
     options = {
 

nixos/modules/services/networking/xl2tpd.nix

···
-{ config, stdenv, pkgs, lib, ... }:
+{ config, pkgs, lib, ... }:
 
 with lib;
 

nixos/modules/services/networking/zerobin.nix

···
-{ config, pkgs, lib, nodes, ... }:
+{ config, pkgs, lib, ... }:
 with lib;
 let
   cfg = config.services.zerobin;

nixos/modules/services/security/oauth2_proxy_nginx.nix

···
-{ pkgs, config, lib, ... }:
+{ config, lib, ... }:
 with lib;
 let
   cfg = config.services.oauth2_proxy.nginx;

nixos/modules/services/security/tor.nix

···
             ];
           }
         '';
-        type = types.loaOf (types.submodule ({name, config, ...}: {
+        type = types.loaOf (types.submodule ({name, ...}: {
           options = {
 
              name = mkOption {
···
              authorizeClient = mkOption {
                default = null;
                description = "If configured, the hidden service is accessible for authorized clients only.";
-               type = types.nullOr (types.submodule ({config, ...}: {
+               type = types.nullOr (types.submodule ({...}: {
 
                  options = {
 

nixos/modules/services/torrent/flexget.nix

···
-{ config, lib, pkgs, timezone, ... }:
+{ config, lib, pkgs, ... }:
 
 with lib;
 

nixos/modules/services/web-apps/matomo.nix

···
-{ config, lib, pkgs, services, ... }:
+{ config, lib, pkgs, ... }:
 with lib;
 let
   cfg = config.services.matomo;

nixos/modules/services/web-apps/youtrack.nix

···
-{ config, lib, pkgs, options, ... }:
+{ config, lib, pkgs, ... }:
 
 with lib;
 

nixos/modules/services/web-servers/apache-httpd/limesurvey.nix

···
-{ config, lib, pkgs, serverInfo, php, ... }:
+{ config, lib, pkgs, serverInfo, ... }:
 
 with lib;
 

nixos/modules/services/web-servers/apache-httpd/mercurial.nix

···
-{ config, pkgs, serverInfo, lib, ... }:
+{ config, pkgs, lib, ... }:
 
 let
   inherit (pkgs) mercurial;

nixos/modules/services/web-servers/apache-httpd/wordpress.nix

···
-{ config, lib, pkgs, serverInfo, php, ... }:
+{ config, lib, pkgs, serverInfo, ... }:
 # http://codex.wordpress.org/Hardening_WordPress
 
 with lib;

nixos/modules/services/web-servers/nginx/vhost-options.nix

···
 # has additional options that affect the web server as a whole, like
 # the user/group to run under.)
 
-{ config, lib }:
+{ lib, ... }:
 
 with lib;
 {

nixos/modules/services/web-servers/zope2.nix

···
 
   cfg = config.services.zope2;
 
-  zope2Opts = { name, config, ... }: {
+  zope2Opts = { name, ... }: {
     options = {
 
       name = mkOption {

nixos/modules/services/x11/display-managers/auto.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/services/x11/terminal-server.nix

···
 # not, a X server (Xvfb) is started for that user.  The Xvfb instances
 # persist across VNC sessions.
 
-{ config, lib, pkgs, ... }:
+{ lib, pkgs, ... }:
 
 with lib;
 

nixos/modules/services/x11/window-managers/default.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/services/x11/window-managers/wmii.nix

···
-{ config, lib, pkgs, options, modulesPath, ... }:
+{ config, lib, pkgs, ... }:
 
 with lib;
 let

nixos/modules/services/x11/xserver.nix

···
-{ config, lib, pkgs, pkgs_i686, ... }:
+{ config, lib, pkgs, ... }:
 
 with lib;
 

nixos/modules/system/activation/top-level.nix

···
       default = [];
       example = lib.literalExample "[ ({ original = pkgs.openssl; replacement = pkgs.callPackage /path/to/openssl { }; }) ]";
       type = types.listOf (types.submodule (
-        { options, ... }: {
+        { ... }: {
           options.original = mkOption {
             type = types.package;
             description = "The original package to override.";

nixos/modules/system/boot/kexec.nix

···
-{ config, pkgs, lib, ... }:
+{ pkgs, lib, ... }:
 
 {
   config = lib.mkIf (pkgs.kexectools.meta.available) {

nixos/modules/system/boot/loader/loader.nix

···
-{ config, lib, pkgs, ... }:
+{ lib, ... }:
 
 with lib;
 

nixos/modules/system/boot/networkd.nix

···
 
   };
 
-  networkConfig = { name, config, ... }: {
+  networkConfig = { config, ... }: {
     config = {
       matchConfig = optionalAttrs (config.name != null) {
         Name = config.name;

nixos/modules/system/boot/resolved.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 let

nixos/modules/system/boot/systemd.nix

···
         x = pkgs.writeTextFile { name = "unit-script"; executable = true; destination = "/bin/${mkScriptName name}"; inherit text; };
     in "${x}/bin/${mkScriptName name}";
 
-  unitConfig = { name, config, ... }: {
+  unitConfig = { config, ... }: {
     config = {
       unitConfig =
         optionalAttrs (config.requires != [])
···
       ];
   };
 
-  mountConfig = { name, config, ... }: {
+  mountConfig = { config, ... }: {
     config = {
       mountConfig =
         { What = config.what;
···
     };
   };
 
-  automountConfig = { name, config, ... }: {
+  automountConfig = { config, ... }: {
     config = {
       automountConfig =
         { Where = config.where;

nixos/modules/system/boot/timesyncd.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/tasks/bcache.nix

···
-{ config, pkgs, ... }:
+{ pkgs, ... }:
 
 {
 

nixos/modules/tasks/filesystems/ext.nix

···
-{ config, pkgs, ... }:
+{ pkgs, ... }:
 
 {
   config = {

nixos/modules/tasks/network-interfaces-systemd.nix

···
-{ config, lib, pkgs, utils, ... }:
+{ config, lib, utils, ... }:
 
 with utils;
 with lib;

nixos/modules/tasks/network-interfaces.nix

···
-{ config, options, lib, pkgs, utils, stdenv, ... }:
+{ config, options, lib, pkgs, utils, ... }:
 
 with lib;
 with utils;

nixos/modules/tasks/scsi-link-power-management.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/tasks/swraid.nix

···
-{ config, pkgs, ... }:
+{ pkgs, ... }:
 
 {
 

nixos/modules/tasks/trackpoint.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 
 with lib;
 

nixos/modules/testing/service-runner.nix

···
-{ config, lib, pkgs, ... }:
+{ lib, pkgs, ... }:
 
 with lib;
 

nixos/modules/virtualisation/amazon-options.nix

···
-{ config, lib, pkgs, ... }:
+{ config, lib, ... }:
 {
   options = {
     ec2 = {

nixos/modules/virtualisation/azure-common.nix

···
-{ config, lib, pkgs, ... }:
+{ lib, pkgs, ... }:
 
 with lib;
 {

nixos/modules/virtualisation/azure-config-user.nix

···
-{ config, pkgs, modulesPath, ... }:
+{ modulesPath, ... }:
 
 {
   # To build the configuration or use nix-env, you need to run

nixos/modules/virtualisation/azure-config.nix

···
-{ config, pkgs, modulesPath, ... }:
+{ modulesPath, ... }:
 
 {
   imports = [ "${modulesPath}/virtualisation/azure-image.nix" ];

nixos/modules/virtualisation/brightbox-config.nix

···
-{ config, pkgs, modulesPath, ... }:
+{ modulesPath, ... }:
 
 {
   imports = [ "${modulesPath}/virtualisation/brightbox-image.nix" ];

nixos/modules/virtualisation/containers.nix

···
 
   system = config.nixpkgs.localSystem.system;
 
-  bindMountOpts = { name, config, ... }: {
+  bindMountOpts = { name, ... }: {
 
     options = {
       mountPoint = mkOption {
···
 
   };
 
-  allowedDeviceOpts = { name, config, ... }: {
+  allowedDeviceOpts = { ... }: {
     options = {
       node = mkOption {
         example = "/dev/net/tun";

nixos/modules/virtualisation/docker-image.nix

···
-{ config, pkgs, ... }:
+{ ... }:
 
 {
   imports = [

nixos/modules/virtualisation/google-compute-config.nix

···
-{ config, pkgs, ... }:
+{ ... }:
 
 {
   imports = [ <nixpkgs/nixos/modules/virtualisation/google-compute-image.nix> ];

nixos/modules/virtualisation/lxc-container.nix

···
-{ config, pkgs, lib, ... }:
+{ lib, ... }:
 
 with lib;
 

nixos/modules/virtualisation/nova-config.nix

···
-{ config, lib, pkgs, ... }:
+{ lib, ... }:
 
 with lib;
 

nixos/modules/virtualisation/xen-domU.nix

···
 # Common configuration for Xen DomU NixOS virtual machines.
 
-{ config, pkgs, ... }:
+{ ... }:
 
 {
   boot.loader.grub.version = 2;

nixos/release.nix

···
 
 
   makeIso =
-    { module, type, maintainers ? ["eelco"], system }:
+    { module, type, system, ... }:
 
     with import nixpkgs { inherit system; };
 
···
 
 
   makeSdImage =
-    { module, maintainers ? ["dezgeg"], system }:
+    { module, system, ... }:
 
     with import nixpkgs { inherit system; };
 
···
   buildFromConfig = module: sel: forAllSystems (system: hydraJob (sel (import ./lib/eval-config.nix {
     inherit system;
     modules = [ module versionModule ] ++ singleton
-      ({ config, lib, ... }:
+      ({ ... }:
       { fileSystems."/".device  = mkDefault "/dev/sda1";
         boot.loader.grub.device = mkDefault "/dev/sda";
       });
···
 
   channel = import lib/make-channel.nix { inherit pkgs nixpkgs version versionSuffix; };
 
-  manual = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.manual);
-  manualEpub = (buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.manualEpub));
-  manpages = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.manpages);
-  manualGeneratedSources = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.generatedSources);
-  options = (buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.optionsJSON)).x86_64-linux;
+  manual = buildFromConfig ({ ... }: { }) (config: config.system.build.manual.manual);
+  manualEpub = (buildFromConfig ({ ... }: { }) (config: config.system.build.manual.manualEpub));
+  manpages = buildFromConfig ({ ... }: { }) (config: config.system.build.manual.manpages);
+  manualGeneratedSources = buildFromConfig ({ ... }: { }) (config: config.system.build.manual.generatedSources);
+  options = (buildFromConfig ({ ... }: { }) (config: config.system.build.manual.optionsJSON)).x86_64-linux;
 
 
   # Build the initial ramdisk so Hydra can keep track of its size over time.
-  initialRamdisk = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.initialRamdisk);
+  initialRamdisk = buildFromConfig ({ ... }: { }) (config: config.system.build.initialRamdisk);
 
   netboot = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system: makeNetboot {
     inherit system;
···
   dummy = forAllSystems (system: pkgs.runCommand "dummy"
     { toplevel = (import lib/eval-config.nix {
         inherit system;
-        modules = singleton ({ config, pkgs, ... }:
+        modules = singleton ({ ... }:
           { fileSystems."/".device  = mkDefault "/dev/sda1";
             boot.loader.grub.device = mkDefault "/dev/sda";
             system.nixos.stateVersion = mkDefault "18.03";
···
 
   closures = {
 
-    smallContainer = makeClosure ({ pkgs, ... }:
+    smallContainer = makeClosure ({ ... }:
       { boot.isContainer = true;
         services.openssh.enable = true;
       });
 
-    tinyContainer = makeClosure ({ pkgs, ... }:
+    tinyContainer = makeClosure ({ ... }:
       { boot.isContainer = true;
         imports = [ modules/profiles/minimal.nix ];
       });
 
-    ec2 = makeClosure ({ pkgs, ... }:
+    ec2 = makeClosure ({ ... }:
       { imports = [ modules/virtualisation/amazon-image.nix ];
       });
 
-    kde = makeClosure ({ pkgs, ... }:
+    kde = makeClosure ({ ... }:
       { services.xserver.enable = true;
         services.xserver.displayManager.sddm.enable = true;
         services.xserver.desktopManager.plasma5.enable = true;
       });
 
-    xfce = makeClosure ({ pkgs, ... }:
+    xfce = makeClosure ({ ... }:
       { services.xserver.enable = true;
         services.xserver.desktopManager.xfce.enable = true;
       });

nixos/tests/acme.nix

···
 let
-  commonConfig = { config, lib, pkgs, nodes, ... }: {
+  commonConfig = { lib, nodes, ... }: {
     networking.nameservers = [
       nodes.letsencrypt.config.networking.primaryIPAddress
     ];

nixos/tests/ammonite.nix

···
 
   nodes = {
     amm =
-      { config, pkgs, ... }:
+      { pkgs, ... }:
         {
           environment.systemPackages = [ pkgs.ammonite ];
         };

nixos/tests/atd.nix

···
-import ./make-test.nix ({ pkgs, lib, ... }:
+import ./make-test.nix ({ pkgs, ... }:
 
 {
   name = "atd";
···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { ... }:
     { services.atd.enable = true;
       users.users.alice = { isNormalUser = true; };
     };

nixos/tests/avahi.nix

···
   };
 
   nodes = let
-    cfg = { config, pkgs, ... }: {
+    cfg = { ... }: {
       services.avahi = {
         enable = true;
         nssmdns = true;

nixos/tests/beegfs.nix

···
-import ./make-test.nix ({ pkgs, ... } :
+import ./make-test.nix ({ ... } :
 
 let
   connAuthFile="beegfs/auth-def.key";
 
-  client = { config, pkgs, lib, ... } : {
+  client = { pkgs, ... } : {
     networking.firewall.enable = false;
     services.beegfsEnable = true;
     services.beegfs.default = {
···
   };
 
 
-  server = service : { config, pkgs, lib, ... } : {
+  server = service : { pkgs, ... } : {
     networking.firewall.enable = false;
     boot.initrd.postDeviceCommands = ''
       ${pkgs.e2fsprogs}/bin/mkfs.ext4 -L data /dev/vdb

nixos/tests/bittorrent.nix

···
 
   nodes =
     { tracker =
-        { config, pkgs, ... }:
+        { pkgs, ... }:
         { environment.systemPackages = [ pkgs.transmission pkgs.opentracker ];
 
           # We need Apache on the tracker to serve the torrents.
···
         };
 
       router =
-        { config, pkgs, ... }:
+        { pkgs, ... }:
         { environment.systemPackages = [ pkgs.miniupnpd ];
           virtualisation.vlans = [ 1 2 ];
           networking.nat.enable = true;
···
         };
 
       client1 =
-        { config, pkgs, nodes, ... }:
+        { pkgs, nodes, ... }:
         { environment.systemPackages = [ pkgs.transmission ];
           virtualisation.vlans = [ 2 ];
           networking.defaultGateway =
···
         };
 
       client2 =
-        { config, pkgs, ... }:
+        { pkgs, ... }:
         { environment.systemPackages = [ pkgs.transmission ];
           networking.firewall.enable = false;
         };

nixos/tests/borgbackup.nix

···
   };
 
   nodes = {
-    client = { config, pkgs, ... }: {
+    client = { ... }: {
       services.borgbackup.jobs = {
         
         local = rec {
···
       };
     };
 
-    server = { config, pkgs, ... }: {
+    server = { ... }: {
       services.openssh = {
         enable = true;
         passwordAuthentication = false;

nixos/tests/buildbot.nix

···
   name = "buildbot";
 
   nodes = {
-    bbmaster = { config, pkgs, ... }: {
+    bbmaster = { pkgs, ... }: {
       services.buildbot-master = {
         enable = true;
         package = pkgs.buildbot-full;
···
       environment.systemPackages = with pkgs; [ git buildbot-full ];
     };
 
-    bbworker = { config, pkgs, ... }: {
+    bbworker = { pkgs, ... }: {
       services.buildbot-worker = {
         enable = true;
         masterUrl = "bbmaster:9989";
···
       environment.systemPackages = with pkgs; [ git buildbot-worker ];
     };
 
-    gitrepo = { config, pkgs, ... }: {
+    gitrepo = { pkgs, ... }: {
       services.openssh.enable = true;
       networking.firewall.allowedTCPPorts = [ 22 9418 ];
       environment.systemPackages = with pkgs; [ git ];

nixos/tests/cadvisor.nix

···
   };
 
   nodes = {
-    machine = { config, pkgs, ... }: {
+    machine = { ... }: {
       services.cadvisor.enable = true;
     };
 
-    influxdb = { config, pkgs, lib, ... }: with lib; {
+    influxdb = { lib, ... }: with lib; {
       services.cadvisor.enable = true;
       services.cadvisor.storageDriver = "influxdb";
       services.influxdb.enable = true;

nixos/tests/cassandra.nix

···
   name = "cassandra-ci";
 
   nodes = {
-    cass0 = {pkgs, config, nodes, ...}: nodeCfg nodes "192.168.1.1" {};
-    cass1 = {pkgs, config, nodes, ...}: nodeCfg nodes "192.168.1.2" {};
-    cass2 = {pkgs, config, nodes, ...}: nodeCfg nodes "192.168.1.3" {
+    cass0 = { nodes, ... }: nodeCfg nodes "192.168.1.1" {};
+    cass1 = { nodes, ... }: nodeCfg nodes "192.168.1.2" {};
+    cass2 = { nodes, ... }: nodeCfg nodes "192.168.1.3" {
       extraParams = [
         ''JVM_OPTS="$JVM_OPTS -Dcassandra.replace_address=192.168.1.2"''
       ];

nixos/tests/ceph.nix

···
   };
 
   nodes = {
-    aio = { config, pkgs, ... }: {
+    aio = { pkgs, ... }: {
       virtualisation = {
         emptyDiskImages = [ 20480 20480 ];
         vlans = [ 1 ];
···
     };
   };
   
-  testScript = { nodes, ... }: ''
+  testScript = { ... }: ''
     startAll;
 
     $aio->waitForUnit("network.target");

nixos/tests/cjdns.nix

···
   carolPassword = "678287829ce4c67bc8b227e56d94422ee1b85fa11618157b2f591de6c6322b52";
 
   basicConfig =
-    { config, pkgs, ... }:
+    { ... }:
     { services.cjdns.enable = true;
 
       # Turning off DHCP isn't very realistic but makes
···
   nodes = rec
     { # Alice finds peers over over ETHInterface.
       alice =
-        { config, ... }:
+        { ... }:
         { imports = [ basicConfig ];
 
           services.cjdns.ETHInterface.bind = "eth1";
···
 
       # Bob explicitly connects to Carol over UDPInterface.
       bob =
-        { config, lib, nodes, ... }:
+        { ... }:
 
         { imports = [ basicConfig ];
 
···
       # Carol listens on ETHInterface and UDPInterface,
       # but knows neither Alice or Bob.
       carol =
-        { config, lib, nodes, ... }:
+        { ... }:
         { imports = [ basicConfig ];
 
           environment.etc."cjdns.keys".text = ''

nixos/tests/cloud-init.nix

···
     maintainers = [ lewo ];
   };
   machine =
-    { config, pkgs, ... }:
+    { ... }:
     {
       virtualisation.qemu.options = [ "-cdrom" "${metadataDrive}/metadata.iso" ];
       services.cloud-init.enable = true;

nixos/tests/common/user-account.nix

···
-{ lib, ... }:
+{ ... }:
 
 { users.users.alice =
     { isNormalUser = true;

nixos/tests/containers-bridge.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
     { imports = [ ../modules/installer/cd-dvd/channel.nix ];
       virtualisation.writableStore = true;
       virtualisation.memorySize = 768;

nixos/tests/containers-extra_veth.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
     { imports = [ ../modules/installer/cd-dvd/channel.nix ];
       virtualisation.writableStore = true;
       virtualisation.memorySize = 768;

nixos/tests/containers-hosts.nix

···
   };
 
   machine =
-    { config, pkgs, lib, ... }:
+    { lib, ... }:
     {
       virtualisation.memorySize = 256;
       virtualisation.vlans = [];

nixos/tests/containers-ipv4.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
     { imports = [ ../modules/installer/cd-dvd/channel.nix ];
       virtualisation.writableStore = true;
       virtualisation.memorySize = 768;

nixos/tests/containers-ipv6.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
     { imports = [ ../modules/installer/cd-dvd/channel.nix ];
       virtualisation.writableStore = true;
       virtualisation.memorySize = 768;

nixos/tests/containers-macvlans.nix

···
   nodes = {
 
     machine1 =
-      { config, pkgs, lib, ... }:
+      { lib, ... }:
       {
         virtualisation.memorySize = 256;
         virtualisation.vlans = [ 1 ];
···
       };
 
     machine2 =
-      { config, pkgs, ... }:
+      { ... }:
       {
         virtualisation.memorySize = 256;
         virtualisation.vlans = [ 1 ];

nixos/tests/containers-physical_interfaces.nix

···
   };
 
   nodes = {
-    server = { config, pkgs, ... }:
+    server = { ... }:
       {
         virtualisation.memorySize = 256;
         virtualisation.vlans = [ 1 ];
···
           };
         };
       };
-    bridged = { config, pkgs, ... }: {
+    bridged = { ... }: {
       virtualisation.memorySize = 128;
       virtualisation.vlans = [ 1 ];
 
···
       };
     };
 
-    bonded = { config, pkgs, ... }: {
+    bonded = { ... }: {
       virtualisation.memorySize = 128;
       virtualisation.vlans = [ 1 ];
 
···
       };
     };
 
-    bridgedbond = { config, pkgs, ... }: {
+    bridgedbond = { ... }: {
       virtualisation.memorySize = 128;
       virtualisation.vlans = [ 1 ];
 

nixos/tests/containers-portforward.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
     { imports = [ ../modules/installer/cd-dvd/channel.nix ];
       virtualisation.writableStore = true;
       virtualisation.memorySize = 768;

nixos/tests/containers-reloadable.nix

···
   };
 
   nodes = {
-    client = { lib, pkgs, ... }: {
+    client = { ... }: {
       imports = [ client_base ];
     };
 
-    client_c1 = { lib, pkgs, ... }: {
+    client_c1 = { lib, ... }: {
       imports = [ client_base ];
 
       containers.test1.config = {
···
         services.httpd.adminAddr = "[e-mail]";
       };
     };
-    client_c2 = { lib, pkgs, ... }: {
+    client_c2 = { lib, ... }: {
       imports = [ client_base ];
 
       containers.test1.config = {

nixos/tests/containers-restart_networking.nix

···
       };
     };
   };
-in import ./make-test.nix ({ pkgs, lib, ...} :
+in import ./make-test.nix ({ pkgs, ...} :
 {
   name = "containers-restart_networking";
   meta = with pkgs.stdenv.lib.maintainers; {
···
   };
 
   nodes = {
-    client = { lib, pkgs, ... }: client_base // {
+    client = { lib, ... }: client_base // {
       virtualisation.vlans = [ 1 ];
 
       networking.bridges.br0 = {
···
       };
 
     };
-    client_eth1 = { lib, pkgs, ... }: client_base // {
+    client_eth1 = { lib, ... }: client_base // {
       networking.bridges.br0 = {
         interfaces = [ "eth1" ];
         rstp = false;
···
         br0.ipv4.addresses = [ { address = "192.168.1.2"; prefixLength = 24; } ];
       };
     };
-    client_eth1_rstp = { lib, pkgs, ... }: client_base // {
+    client_eth1_rstp = { lib, ... }: client_base // {
       networking.bridges.br0 = {
         interfaces = [ "eth1" ];
         rstp = true;

nixos/tests/containers-tmpfs.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
     { imports = [ ../modules/installer/cd-dvd/channel.nix ];
       virtualisation.writableStore = true;
       virtualisation.memorySize = 768;

nixos/tests/couchdb.nix

···
 
   nodes = {
     couchdb1 =
-      { pkgs, config, ... }:
+      { pkgs, ... }:
 
       { environment.systemPackages = with pkgs; [ jq ];
         services.couchdb.enable = true;
       };
 
     couchdb2 =
-      { pkgs, config, ... }:
+      { pkgs, ... }:
 
       { environment.systemPackages = with pkgs; [ jq ];
         services.couchdb.enable = true;

nixos/tests/deluge.nix

···
 
   nodes = {
     server =
-      { pkgs, config, ... }:
+      { ... }:
 
       { services.deluge = {
           enable = true;

nixos/tests/dnscrypt-proxy.nix

···
     # A client running the recommended setup: DNSCrypt proxy as a forwarder
     # for a caching DNS client.
     client =
-    { config, pkgs, ... }:
+    { ... }:
     let localProxyPort = 43; in
     {
       security.apparmor.enable = true;

nixos/tests/docker-edge.nix

···
 
   nodes = {
     docker =
-      { config, pkgs, ... }:
+      { pkgs, ... }:
         {
           virtualisation.docker.enable = true;
           virtualisation.docker.package = pkgs.docker-edge;

nixos/tests/docker-registry.nix

···
   };
 
   nodes = {
-    registry = { config, pkgs, ... }: {
+    registry = { ... }: {
       services.dockerRegistry.enable = true;
       services.dockerRegistry.enableDelete = true;
       services.dockerRegistry.port = 8080;
···
       networking.firewall.allowedTCPPorts = [ 8080 ];
     };
 
-    client1 = { config, pkgs, ...}: {
+    client1 = { ... }: {
       virtualisation.docker.enable = true;
       virtualisation.docker.extraOptions = "--insecure-registry registry:8080";
     };
 
-    client2 = { config, pkgs, ...}: {
+    client2 = { ... }: {
       virtualisation.docker.enable = true;
       virtualisation.docker.extraOptions = "--insecure-registry registry:8080";
     };

nixos/tests/docker-tools-overlay.nix

···
 
   nodes = {
     docker =
-      { config, pkgs, ... }:
+      { ... }:
       {
         virtualisation.docker.enable = true;
         virtualisation.docker.storageDriver = "overlay";  # defaults to overlay2

nixos/tests/docker-tools.nix

···
 
   nodes = {
     docker =
-      { config, pkgs, ... }: {
+      { ... }: {
         virtualisation = {
           diskSize = 2048;
           docker.enable = true;

nixos/tests/docker.nix

···
 
   nodes = {
     docker =
-      { config, pkgs, ... }:
+      { pkgs, ... }:
         {
           virtualisation.docker.enable = true;
           virtualisation.docker.package = pkgs.docker;

nixos/tests/ecryptfs.nix

···
-import ./make-test.nix ({ pkgs, ... }:
+import ./make-test.nix ({ ... }:
 {
   name = "ecryptfs";
 
-  machine = { config, pkgs, ... }: {
+  machine = { pkgs, ... }: {
     imports = [ ./common/user-account.nix ];
     boot.kernelModules = [ "ecryptfs" ];
     security.pam.enableEcryptfs = true;

nixos/tests/elk.nix

···
     };
     nodes = {
       one =
-        { config, pkgs, ... }: {
+        { pkgs, ... }: {
             # Not giving the machine at least 2060MB results in elasticsearch failing with the following error:
             #
             #   OpenJDK 64-Bit Server VM warning:

nixos/tests/emacs-daemon.nix

···
   enableOCR = true;
 
   machine =
-    { config, pkgs, ... }:
+    { ... }:
 
     { imports = [ ./common/x11.nix ];
       services.emacs = {

nixos/tests/env.nix

···
     maintainers = [ nequissimus ];
   };
 
-  machine = { config, lib, pkgs, ... }:
+  machine = { pkgs, ... }:
     {
       boot.kernelPackages = pkgs.linuxPackages;
       environment.etc."plainFile".text = ''

nixos/tests/etcd-cluster.nix

···
   };
 
   nodes = {
-    node1 = { config, pkgs, nodes, ... }: {
+    node1 = { ... }: {
       require = [nodeConfig];
       services.etcd = {
         initialCluster = ["node1=https://node1:2380" "node2=https://node2:2380"];
···
       };
     };
 
-    node2 = { config, pkgs, ... }: {
+    node2 = { ... }: {
       require = [nodeConfig];
       services.etcd = {
         initialCluster = ["node1=https://node1:2380" "node2=https://node2:2380"];
···
       };
     };
 
-    node3 = { config, pkgs, ... }: {
+    node3 = { ... }: {
       require = [nodeConfig];
       services.etcd = {
         initialCluster = ["node1=https://node1:2380" "node2=https://node2:2380" "node3=https://node3:2380"];

nixos/tests/etcd.nix

···
   };
 
   nodes = {
-    node = { config, pkgs, nodes, ... }: {
+    node = { ... }: {
       services.etcd.enable = true;
     };
   };

nixos/tests/ferm.nix

···
 
   nodes =
     { client =
-        { config, pkgs, ... }:
+        { pkgs, ... }:
         with pkgs.lib;
         {
           networking = {
···
           };
       };
       server =
-        { config, pkgs, ... }:
+        { pkgs, ... }:
         with pkgs.lib;
         {
           networking = {

nixos/tests/firefox.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
 
     { imports = [ ./common/x11.nix ];
       environment.systemPackages = [ pkgs.firefox pkgs.xdotool ];

nixos/tests/firewall.nix

···
 
   nodes =
     { walled =
-        { config, pkgs, nodes, ... }:
+        { ... }:
         { networking.firewall.enable = true;
           networking.firewall.logRefusedPackets = true;
           services.httpd.enable = true;
···
       # original walled configuration so that there is a change in the service
       # file.
       walled2 =
-        { config, pkgs, nodes, ... }:
+        { ... }:
         { networking.firewall.enable = true;
           networking.firewall.rejectPackets = true;
         };
 
       attacker =
-        { config, pkgs, ... }:
+        { ... }:
         { services.httpd.enable = true;
           services.httpd.adminAddr = "[e-mail]";
           networking.firewall.enable = false;

nixos/tests/flannel.nix

···
       networking.firewall.allowedUDPPorts = [ 8472 ];
     };
   in {
-    etcd = { config, pkgs, ... }: {
+    etcd = { ... }: {
       services = {
         etcd = {
           enable = true;
···
       networking.firewall.allowedTCPPorts = [ 2379 ];
     };
 
-    node1 = { config, ... }: {
+    node1 = { ... }: {
       require = [flannelConfig];
     };
 
-    node2 = { config, ... }: {
+    node2 = { ... }: {
       require = [flannelConfig];
     };
   };

nixos/tests/flatpak.nix

···
     maintainers = pkgs.flatpak.meta.maintainers;
   };
 
-  machine = { config, pkgs, ... }: {
+  machine = { pkgs, ... }: {
     imports = [ ./common/x11.nix ];
     services.xserver.desktopManager.gnome3.enable = true; # TODO: figure out minimal environment where the tests work
     environment.gnome3.excludePackages = pkgs.gnome3.optionalPackages;

nixos/tests/fwupd.nix

···
     maintainers = pkgs.fwupd.meta.maintainers;
   };
 
-  machine = { config, pkgs, ... }: {
+  machine = { pkgs, ... }: {
     services.fwupd.enable = true;
     environment.systemPackages = with pkgs; [ gnome-desktop-testing ];
     environment.variables.XDG_DATA_DIRS = [ "${pkgs.fwupd.installedTests}/share" ];

nixos/tests/gitlab.nix

···
   };
 
   nodes = {
-    gitlab = { config, pkgs, ... }: {
+    gitlab = { ... }: {
       virtualisation.memorySize = 768;
 
       services.nginx = {

nixos/tests/gitolite.nix

···
   nodes = {
 
     server =
-      { config, pkgs, lib, ... }:
+      { ... }:
       {
         services.gitolite = {
           enable = true;
···
       };
 
     client =
-      { config, pkgs, lib, ... }:
+      { pkgs, ... }:
       {
         environment.systemPackages = [ pkgs.git ];
         programs.ssh.extraConfig = ''

nixos/tests/gnome3-gdm.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { ... }:
 
     { imports = [ ./common/user-account.nix ];
 

nixos/tests/gnome3.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { ... }:
 
     { imports = [ ./common/user-account.nix ];
 

nixos/tests/gocd-agent.nix

···
 
   nodes = {
     gocd_agent =
-      { config, pkgs, ... }:
+      { ... }:
       {
         virtualisation.memorySize = 2046;
         services.gocd-agent = {

nixos/tests/gocd-server.nix

···
 
 nodes = {
   gocd_server =
-    { config, pkgs, ... }:
+    { ... }:
     {
       virtualisation.memorySize = 2046;
       services.gocd-server.enable = true;

nixos/tests/grafana.nix

···
     maintainers = [ willibutz ];
   };
 
-  machine = { config, pkgs, ... }: {
+  machine = { ... }: {
     services.grafana = {
       enable = true;
       addr = "localhost";

nixos/tests/graphite.nix

···
-import ./make-test.nix ({ pkgs, ...} :
+import ./make-test.nix ({ ... } :
 {
   name = "graphite";
   nodes = {
     one =
-      { config, pkgs, ... }: {
+      { ... }: {
         virtualisation.memorySize = 1024;
         time.timeZone = "UTC";
         services.graphite = {

nixos/tests/hadoop/hdfs.nix

···
-import ../make-test.nix ({pkgs, ...}: {
+import ../make-test.nix ({...}: {
   nodes = {
-    namenode = {pkgs, config, ...}: {
+    namenode = {pkgs, ...}: {
       services.hadoop = {
         package = pkgs.hadoop_3_1;
         hdfs.namenode.enabled = true;
···
         8020 # namenode.rpc-address
       ];
     };
-    datanode = {pkgs, config, ...}: {
+    datanode = {pkgs, ...}: {
       services.hadoop = {
         package = pkgs.hadoop_3_1;
         hdfs.datanode.enabled = true;

nixos/tests/hadoop/yarn.nix

···
-import ../make-test.nix ({pkgs, ...}: {
+import ../make-test.nix ({...}: {
   nodes = {
-    resourcemanager = {pkgs, config, ...}: {
+    resourcemanager = {pkgs, ...}: {
       services.hadoop.package = pkgs.hadoop_3_1;
       services.hadoop.yarn.resourcemanager.enabled = true;
       services.hadoop.yarnSite = {
···
         8031 # resourcemanager.resource-tracker.address
       ];
     };
-    nodemanager = {pkgs, config, ...}: {
+    nodemanager = {pkgs, ...}: {
       services.hadoop.package = pkgs.hadoop_3_1;
       services.hadoop.yarn.nodemanager.enabled = true;
       services.hadoop.yarnSite = {

nixos/tests/haka.nix

···
 
   nodes = {
     haka =
-      { config, pkgs, ... }:
+      { ... }:
         {
           services.haka.enable = true;
         };

nixos/tests/haproxy.nix

···
 import ./make-test.nix ({ pkgs, ...}: {
   name = "haproxy";
   nodes = {
-    machine = { config, ...}: {
+    machine = { ... }: {
       imports = [ ../modules/profiles/minimal.nix ];
       services.haproxy = {
         enable = true;

nixos/tests/hardened.nix

···
   };
 
   machine =
-    { config, lib, pkgs, ... }:
+    { lib, pkgs, ... }:
     with lib;
     { users.users.alice = { isNormalUser = true; extraGroups = [ "proc" ]; };
       users.users.sybil = { isNormalUser = true; group = "wheel"; };

nixos/tests/hibernate.nix

···
       systemd.services.listener.serviceConfig.ExecStart = "${pkgs.netcat}/bin/nc -l 4444 -k";
     };
 
-    probe = { config, lib, pkgs, ...}: {
+    probe = { pkgs, ...}: {
       environment.systemPackages = [ pkgs.netcat ];
     };
   };

nixos/tests/hitch/default.nix

···
   meta = with pkgs.stdenv.lib.maintainers; {
     maintainers = [ jflanglois ];
   };
-  machine = { config, pkgs, ... }: {
+  machine = { pkgs, ... }: {
     environment.systemPackages = [ pkgs.curl ];
     services.hitch = {
       enable = true;

nixos/tests/hocker-fetchdocker/machine.nix

···
-{ config, pkgs, ... }:
+{ pkgs, ... }:
 { nixpkgs.config.packageOverrides = pkgs': {
     hello-world-container = pkgs'.callPackage ./hello-world-container.nix { };
   };

nixos/tests/home-assistant.nix

···
 
   nodes = {
     hass =
-      { config, pkgs, ... }:
+      { pkgs, ... }:
       {
         environment.systemPackages = with pkgs; [
           mosquitto

nixos/tests/hound.nix

···
   meta = with pkgs.stdenv.lib.maintainers; {
     maintainers = [ grahamc ];
   };
-  machine = { config, pkgs, ... }: {
+  machine = { pkgs, ... }: {
     services.hound = {
       enable = true;
       config = ''

nixos/tests/hydra/default.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
 
     {
       virtualisation.memorySize = 1024;

nixos/tests/i3wm.nix

···
     maintainers = [ aszlig ];
   };
 
-  machine = { lib, pkgs, ... }: {
+  machine = { lib, ... }: {
     imports = [ ./common/x11.nix ./common/user-account.nix ];
     services.xserver.displayManager.auto.user = "alice";
     services.xserver.windowManager.default = lib.mkForce "i3";
     services.xserver.windowManager.i3.enable = true;
   };
 
-  testScript = { nodes, ... }: ''
+  testScript = { ... }: ''
     $machine->waitForX;
     $machine->waitForFile("/home/alice/.Xauthority");
     $machine->succeed("xauth merge ~alice/.Xauthority");

nixos/tests/influxdb.nix

···
   };
 
   nodes = {
-    one = { config, pkgs, ... }: {
+    one = { ... }: {
       services.influxdb.enable = true;
     };
   };

nixos/tests/initrd-network-ssh/default.nix

···
-import ../make-test.nix ({ pkgs, lib, ... }:
+import ../make-test.nix ({ lib, ... }:
 
 {
   name = "initrd-network-ssh";
···
 
   nodes = with lib; rec {
     server =
-      { config, pkgs, ... }:
+      { config, ... }:
       {
         boot.kernelParams = [
           "ip=${config.networking.primaryIPAddress}:::255.255.255.0::eth1:none"
···
       };
 
     client =
-      { config, pkgs, ... }:
+      { config, ... }:
       {
         environment.etc.knownHosts = {
           text = concatStrings [

nixos/tests/initrd-network.nix

···
 
   meta.maintainers = [ pkgs.stdenv.lib.maintainers.eelco ];
 
-  machine = { config, pkgs, ... }: {
+  machine = { ... }: {
     imports = [ ../modules/profiles/minimal.nix ];
     boot.initrd.network.enable = true;
     boot.initrd.network.postCommands =

nixos/tests/installer.nix

···
 
         # The configuration of the machine used to run "nixos-install".
         machine =
-          { config, lib, pkgs, ... }:
+          { pkgs, ... }:
 
           { imports =
               [ ../modules/profiles/installation-device.nix

nixos/tests/ipfs.nix

···
 
   nodes = {
     adder =
-      { config, pkgs, ... }:
+      { ... }:
       {
         services.ipfs = {
           enable = true;
···
         networking.firewall.allowedTCPPorts = [ 4001 ];
       };
     getter =
-      { config, pkgs, ... }:
+      { ... }:
       {
         services.ipfs = {
           enable = true;

nixos/tests/ipv6.nix

···
   };
 
   nodes =
-    { client = { config, pkgs, ... }: { };
+    { client = { ... }: { };
 
       server =
-        { config, pkgs, ... }:
+        { ... }:
         { services.httpd.enable = true;
           services.httpd.adminAddr = "[e-mail]";
           networking.firewall.allowedTCPPorts = [ 80 ];
         };
 
       router =
-        { config, pkgs, ... }:
+        { ... }:
         { services.radvd.enable = true;
           services.radvd.config =
             ''

nixos/tests/jenkins.nix

···
   nodes = {
 
     master =
-      { config, pkgs, ... }:
+      { ... }:
       { services.jenkins.enable = true;
 
         # should have no effect
···
       };
 
     slave =
-      { config, pkgs, ... }:
+      { ... }:
       { services.jenkinsSlave.enable = true;
 
         users.users.jenkins.extraGroups = [ "users" ];

nixos/tests/kafka.nix

···
     };
 
     nodes = {
-      zookeeper1 = { config, ... }: {
+      zookeeper1 = { ... }: {
         services.zookeeper = {
           enable = true;
         };
···
         networking.firewall.allowedTCPPorts = [ 2181 ];
         virtualisation.memorySize = 1024;
       };
-      kafka = { config, ... }: {
+      kafka = { ... }: {
         services.apache-kafka = {
           enable = true;
           extraProperties = ''

nixos/tests/kernel-copperhead.nix

···
     maintainers = [ nequissimus ];
   };
 
-  machine = { config, lib, pkgs, ... }:
+  machine = { pkgs, ... }:
     {
       boot.kernelPackages = pkgs.linuxPackages_copperhead_lts;
     };

nixos/tests/kernel-latest.nix

···
     maintainers = [ nequissimus ];
   };
 
-  machine = { config, lib, pkgs, ... }:
+  machine = { pkgs, ... }:
     {
       boot.kernelPackages = pkgs.linuxPackages_latest;
     };

nixos/tests/kernel-lts.nix

···
     maintainers = [ nequissimus ];
   };
 
-  machine = { config, lib, pkgs, ... }:
+  machine = { pkgs, ... }:
     {
       boot.kernelPackages = pkgs.linuxPackages;
     };

nixos/tests/kexec.nix

···
     maintainers = [ eelco chaoflow ];
   };
 
-  machine = { config, pkgs, ... }:
+  machine = { ... }:
     { virtualisation.vlans = [ ]; };
 
   testScript =

nixos/tests/krb5/deprecated-config.nix

···
   };
 
   machine =
-    { config, pkgs, ... }: {
+    { ... }: {
       krb5 = {
         enable = true;
         defaultRealm = "ATHENA.MIT.EDU";

nixos/tests/krb5/example-config.nix

···
   };
 
   machine =
-    { config, pkgs, ... }: {
+    { pkgs, ... }: {
       krb5 = {
         enable = true;
         kerberos = pkgs.krb5Full;

nixos/tests/kubernetes/certs.nix

···
 {
   pkgs ? import <nixpkgs> {},
-  internalDomain ? "cloud.yourdomain.net",
   externalDomain ? "myawesomecluster.cluster.yourdomain.net",
   serviceClusterIp ? "10.0.0.1",
-  kubelets
+  kubelets,
+  ...
 }:
 let
    runWithCFSSL = name: cmd:

nixos/tests/kubernetes/dns.nix

···
     config.Entrypoint = "/bin/tail";
   };
 
-  extraConfiguration = { config, pkgs, lib, nodes, ... }: {
+  extraConfiguration = { config, pkgs, ... }: {
     environment.systemPackages = [ pkgs.bind.host ];
     # virtualisation.docker.extraOptions = "--dns=${config.services.kubernetes.addons.dns.clusterIp}";
     services.dnsmasq.enable = true;

nixos/tests/ldap.nix

···
     memberUid: ${ldapUser}
   '';
   mkClient = useDaemon:
-    { config, pkgs, lib, ... }:
+    { lib, ... }:
     {
       virtualisation.memorySize = 256;
       virtualisation.vlans = [ 1 ];
···
   nodes = {
 
     server =
-      { config, pkgs, lib, ... }:
+      { pkgs, ... }:
       {
         virtualisation.memorySize = 256;
         virtualisation.vlans = [ 1 ];

nixos/tests/lightdm.nix

···
     maintainers = [ aszlig ];
   };
 
-  machine = { lib, ... }: {
+  machine = { ... }: {
     imports = [ ./common/user-account.nix ];
     services.xserver.enable = true;
     services.xserver.displayManager.lightdm.enable = true;

nixos/tests/login.nix

···
   };
 
   machine =
-    { config, pkgs, lib, ... }:
+    { pkgs, lib, ... }:
     { boot.kernelPackages = lib.mkIf latestKernel pkgs.linuxPackages_latest;
     };
 

nixos/tests/mathics.nix

···
   };
 
   nodes = {
-    machine = { config, pkgs, ... }: {
+    machine = { ... }: {
       services.mathics.enable = true;
       services.mathics.port = 8888;
     };

nixos/tests/memcached.nix

···
 
   nodes = {
     machine =
-      { config, pkgs, ... }:
+      { ... }:
       {
         imports = [ ../modules/profiles/minimal.nix ];
         services.memcached.enable = true;

nixos/tests/mesos.nix

···
   };
 
   nodes = {
-    master = { config, pkgs, ... }: {
+    master = { ... }: {
       networking.firewall.enable = false;
       services.zookeeper.enable = true;
       services.mesos.master = {
···
       };
     };
 
-    slave = { config, pkgs, ... }: {
+    slave = { ... }: {
       networking.firewall.enable = false;
       networking.nat.enable = true;
       virtualisation.docker.enable = true;

nixos/tests/minio.nix

···
   };
 
   nodes = {
-    machine = { config, pkgs, ... }: {
+    machine = { pkgs, ... }: {
       services.minio = {
         enable = true;
         accessKey = "BKIKJAA5BMMU2RHO6IBB";

nixos/tests/misc.nix

···
   foo = pkgs.writeText "foo" "Hello World";
 
   machine =
-    { config, lib, pkgs, ... }:
+    { lib, ... }:
     with lib;
     { swapDevices = mkOverride 0
         [ { device = "/root/swapfile"; size = 128; } ];

nixos/tests/mongodb.nix

···
 
   nodes = {
     one =
-      { config, pkgs, ... }:
+      { ... }:
         {
           services = {
            mongodb.enable = true;

nixos/tests/morty.nix

···
   nodes =
     { mortyProxyWithKey =
 
-      { config, pkgs, ... }:
+      { ... }:
       { services.morty = {
         enable = true;
 	key = "78a9cd0cfee20c672f78427efb2a2a96036027f0";
···
     };
 
   testScript =
-    { nodes , ... }:
+    { ... }:
     ''
       $mortyProxyWithKey->waitForUnit("default.target");
 

nixos/tests/mpd.nix

···
 
   nodes =
     { client = 
-      { config, pkgs, ... }: { };
+      { ... }: { };
 
       serverALSA =
-        { config, pkgs, ... }: (mkServer {
+        { ... }: (mkServer {
           mpd = defaultMpdCfg // {
             network.listenAddress = "any";
             extraConfig = ''
···
         }) // { networking.firewall.allowedTCPPorts = [ 6600 ]; };
 
       serverPulseAudio =
-        { config, pkgs, ... }: (mkServer {
+        { ... }: (mkServer {
           mpd = defaultMpdCfg // {
             extraConfig = ''
               audio_output {

nixos/tests/mumble.nix

···
 import ./make-test.nix ({ pkgs, ...} : 
 
 let
-  client = { config, pkgs, ... }: {
+  client = { pkgs, ... }: {
     imports = [ ./common/x11.nix ];
     environment.systemPackages = [ pkgs.mumble ];
   };
···
   };
 
   nodes = {
-    server = { config, pkgs, ... }: {
+    server = { config, ... }: {
       services.murmur.enable       = true;
       services.murmur.registerName = "NixOS tests";
       networking.firewall.allowedTCPPorts = [ config.services.murmur.port ];

nixos/tests/munin.nix

···
 
   nodes = {
     one =
-      { config, pkgs, ... }:
+      { config, ... }:
         {
           services = {
            munin-node.enable = true;

nixos/tests/mutable-users.nix

···
   };
 
   nodes = {
-    machine = { config, lib, pkgs, ... }: {
+    machine = { ... }: {
       users.mutableUsers = false;
     };
-    mutable = { config, lib, pkgs, ... }: {
+    mutable = { ... }: {
       users.mutableUsers = true;
     };
   };

nixos/tests/mysql-backup.nix

···
   };
 
   nodes = {
-    master = { config, pkgs, ... }: {
+    master = { pkgs, ... }: {
       services.mysql = {
         enable = true;
         initialDatabases = [ { name = "testdb"; schema = ./testdb.sql; } ];

nixos/tests/mysql-replication.nix

···
 
   nodes = {
     master =
-      { pkgs, config, ... }:
+      { pkgs, ... }:
 
       {
         services.mysql.enable = true;
···
       };
 
     slave1 =
-      { pkgs, config, nodes, ... }:
+      { pkgs, nodes, ... }:
 
       {
         services.mysql.enable = true;
···
       };
 
     slave2 =
-      { pkgs, config, nodes, ... }:
+      { pkgs, nodes, ... }:
 
       {
         services.mysql.enable = true;

nixos/tests/mysql.nix

···
 
   nodes = {
     master =
-      { pkgs, config, ... }:
+      { pkgs, ... }:
 
       {
         services.mysql.enable = true;

nixos/tests/nat.nix

···
 
     nodes =
       { client =
-          { config, pkgs, nodes, ... }:
+          { pkgs, nodes, ... }:
           lib.mkMerge [
             { virtualisation.vlans = [ 1 ];
               networking.firewall.allowPing = true;
···
           ];
 
         router =
-        { config, pkgs, ... }: lib.mkMerge [
+        { ... }: lib.mkMerge [
           routerBase
           { networking.nat.enable = true; }
         ];
 
         routerDummyNoNat =
-        { config, pkgs, ... }: lib.mkMerge [
+        { ... }: lib.mkMerge [
           routerBase
           { networking.nat.enable = false; }
         ];
 
         server =
-          { config, pkgs, ... }:
+          { ... }:
           { virtualisation.vlans = [ 2 ];
             networking.firewall.enable = false;
             services.httpd.enable = true;

nixos/tests/netdata.nix

···
 
   nodes = {
     netdata =
-      { config, pkgs, ... }:
+      { pkgs, ... }:
         {
           environment.systemPackages = with pkgs; [ curl jq ];
           services.netdata.enable = true;

nixos/tests/networking-proxy.nix

···
   nodes = {
     # no proxy
     machine =
-      { config, pkgs, ... }:
+      { ... }:
 
       default-config;
 
     # proxy default
     machine2 =
-      { config, pkgs, ... }:
+      { ... }:
 
       default-config // {
         networking.proxy.default = "http://user:pass@host:port";
···
 
     # specific proxy options
     machine3 =
-      { config, pkgs, ... }:
+      { ... }:
 
       default-config //
       {
···
 
     # mix default + proxy options
     machine4 =
-      { config, pkgs, ... }:
+      { ... }:
 
       default-config // {
         networking.proxy = {

nixos/tests/networking.nix

···
     static = {
       name = "Static";
       nodes.router = router;
-      nodes.client = { config, pkgs, ... }: with pkgs.lib; {
+      nodes.client = { pkgs, ... }: with pkgs.lib; {
         virtualisation.vlans = [ 1 2 ];
         networking = {
           useNetworkd = networkd;
···
           ];
         };
       };
-      testScript = { nodes, ... }:
+      testScript = { ... }:
         ''
           startAll;
 
···
     dhcpSimple = {
       name = "SimpleDHCP";
       nodes.router = router;
-      nodes.client = { config, pkgs, ... }: with pkgs.lib; {
+      nodes.client = { pkgs, ... }: with pkgs.lib; {
         virtualisation.vlans = [ 1 2 ];
         networking = {
           useNetworkd = networkd;
···
           };
         };
       };
-      testScript = { nodes, ... }:
+      testScript = { ... }:
         ''
           startAll;
 
···
     dhcpOneIf = {
       name = "OneInterfaceDHCP";
       nodes.router = router;
-      nodes.client = { config, pkgs, ... }: with pkgs.lib; {
+      nodes.client = { pkgs, ... }: with pkgs.lib; {
         virtualisation.vlans = [ 1 2 ];
         networking = {
           useNetworkd = networkd;
···
           interfaces.eth2.ipv4.addresses = mkOverride 0 [ ];
         };
       };
-      testScript = { nodes, ... }:
+      testScript = { ... }:
         ''
           startAll;
 
···
         '';
     };
     bond = let
-      node = address: { config, pkgs, ... }: with pkgs.lib; {
+      node = address: { pkgs, ... }: with pkgs.lib; {
         virtualisation.vlans = [ 1 2 ];
         networking = {
           useNetworkd = networkd;
···
       name = "Bond";
       nodes.client1 = node "192.168.1.1";
       nodes.client2 = node "192.168.1.2";
-      testScript = { nodes, ... }:
+      testScript = { ... }:
         ''
           startAll;
 
···
         '';
     };
     bridge = let
-      node = { address, vlan }: { config, pkgs, ... }: with pkgs.lib; {
+      node = { address, vlan }: { pkgs, ... }: with pkgs.lib; {
         virtualisation.vlans = [ vlan ];
         networking = {
           useNetworkd = networkd;
···
       name = "Bridge";
       nodes.client1 = node { address = "192.168.1.2"; vlan = 1; };
       nodes.client2 = node { address = "192.168.1.3"; vlan = 2; };
-      nodes.router = { config, pkgs, ... }: with pkgs.lib; {
+      nodes.router = { pkgs, ... }: with pkgs.lib; {
         virtualisation.vlans = [ 1 2 ];
         networking = {
           useNetworkd = networkd;
···
             [ { address = "192.168.1.1"; prefixLength = 24; } ];
         };
       };
-      testScript = { nodes, ... }:
+      testScript = { ... }:
         ''
           startAll;
 
···
     macvlan = {
       name = "MACVLAN";
       nodes.router = router;
-      nodes.client = { config, pkgs, ... }: with pkgs.lib; {
+      nodes.client = { pkgs, ... }: with pkgs.lib; {
         virtualisation.vlans = [ 1 ];
         networking = {
           useNetworkd = networkd;
···
           interfaces.eth1.ipv4.addresses = mkOverride 0 [ ];
         };
       };
-      testScript = { nodes, ... }:
+      testScript = { ... }:
         ''
           startAll;
 
···
         '';
     };
     sit = let
-      node = { address4, remote, address6 }: { config, pkgs, ... }: with pkgs.lib; {
+      node = { address4, remote, address6 }: { pkgs, ... }: with pkgs.lib; {
         virtualisation.vlans = [ 1 ];
         networking = {
           useNetworkd = networkd;
···
       name = "Sit";
       nodes.client1 = node { address4 = "192.168.1.1"; remote = "192.168.1.2"; address6 = "fc00::1"; };
       nodes.client2 = node { address4 = "192.168.1.2"; remote = "192.168.1.1"; address6 = "fc00::2"; };
-      testScript = { nodes, ... }:
+      testScript = { ... }:
         ''
           startAll;
 
···
         '';
     };
     vlan = let
-      node = address: { config, pkgs, ... }: with pkgs.lib; {
+      node = address: { pkgs, ... }: with pkgs.lib; {
         #virtualisation.vlans = [ 1 ];
         networking = {
           useNetworkd = networkd;
···
       name = "vlan";
       nodes.client1 = node "192.168.1.1";
       nodes.client2 = node "192.168.1.2";
-      testScript = { nodes, ... }:
+      testScript = { ... }:
         ''
           startAll;
 
···
     };
     privacy = {
       name = "Privacy";
-      nodes.router = { config, pkgs, ... }: {
+      nodes.router = { ... }: {
         virtualisation.vlans = [ 1 ];
         boot.kernel.sysctl."net.ipv6.conf.all.forwarding" = true;
         networking = {
···
           '';
         };
       };
-      nodes.client = { config, pkgs, ... }: with pkgs.lib; {
+      nodes.client = { pkgs, ... }: with pkgs.lib; {
         virtualisation.vlans = [ 1 ];
         networking = {
           useNetworkd = networkd;
···
           };
         };
       };
-      testScript = { nodes, ... }:
+      testScript = { ... }:
         ''
           startAll;
 

nixos/tests/nexus.nix

···
   nodes = {
 
     server =
-      { config, pkgs, ... }:
+      { ... }:
       { virtualisation.memorySize = 2047; # qemu-system-i386 has a 2047M limit
         virtualisation.diskSize = 2048;
 

nixos/tests/nfs.nix

···
 let
 
   client =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
     { fileSystems = pkgs.lib.mkVMOverride
         [ { mountPoint = "/data";
             device = "server:/data";
···
       client2 = client;
 
       server =
-        { config, pkgs, ... }:
+        { ... }:
         { services.nfs.server.enable = true;
           services.nfs.server.exports =
             ''

nixos/tests/nginx.nix

···
 
   nodes = {
     webserver =
-      { config, pkgs, ... }:
+      { ... }:
       { services.nginx.enable = true;
         services.nginx.commonHttpConfig = ''
         log_format ceeformat '@cee: {"status":"$status",'

nixos/tests/novacomd.nix

···
     maintainers = [ dtzWill ];
   };
 
-  machine = { config, pkgs, ... }: {
+  machine = { ... }: {
     services.novacomd.enable = true;
   };
 

nixos/tests/openssh.nix

···
   nodes = {
 
     server =
-      { config, pkgs, ... }:
+      { ... }:
 
       {
         services.openssh.enable = true;
···
       };
 
     server_lazy =
-      { config, pkgs, ... }:
+      { ... }:
 
       {
         services.openssh = { enable = true; startWhenNeeded = true; };
···
       };
 
     client =
-      { config, pkgs, ... }: { };
+      { ... }: { };
 
   };
 

nixos/tests/owncloud.nix

···
-import ./make-test.nix ({ pkgs, ... }:
+import ./make-test.nix ({ ... }:
 
 {
   name = "owncloud";
   nodes =
     { web =
-        { config, pkgs, ... }:
+        { ... }:
         {
           services.postgresql.enable = true;
           services.httpd = {

nixos/tests/pam-oath-login.nix

···
-import ./make-test.nix ({ pkgs, latestKernel ? false, ... }:
+import ./make-test.nix ({ ... }:
 
 let
   oathSnakeoilSecret = "cdd4083ef8ff1fa9178c6d46bfb1a3";
···
   name = "pam-oath-login";
 
   machine =
-    { config, pkgs, lib, ... }:
+    { ... }:
     {
       security.pam.oath = {
         enable = true;

nixos/tests/partition.nix

···
 in {
   name = "partitiion";
 
-  machine = { config, pkgs, ... }: {
+  machine = { pkgs, ... }: {
     environment.systemPackages = [
       pkgs.pythonPackages.nixpart0
       pkgs.file pkgs.btrfs-progs pkgs.xfsprogs pkgs.lvm2

nixos/tests/peerflix.nix

···
 
   nodes = {
     peerflix =
-      { config, pkgs, ... }:
+      { ... }:
         {
           services.peerflix.enable = true;
         };

nixos/tests/pgjwt.nix

···
   };
 
   nodes = {
-    master = { pkgs, config, ... }:
+    master = { ... }:
     {
       services.postgresql = {
         enable = true;

nixos/tests/phabricator.nix

···
 
   nodes = {
     storage =
-      { config, pkgs, ... }:
+      { ... }:
       { services.nfs.server.enable = true;
         services.nfs.server.exports = ''
           /repos 192.168.1.0/255.255.255.0(rw,no_root_squash)
···
       };
 
     webserver =
-      { config, pkgs, ... }:
+      { pkgs, ... }:
       { fileSystems = pkgs.lib.mkVMOverride
           [ { mountPoint = "/repos";
               device = "storage:/repos";
···
       };
 
     client =
-      { config, pkgs, ... }:
+      { ... }:
       { imports = [ ./common/x11.nix ];
         services.xserver.desktopManager.plasma5.enable = true;
       };

nixos/tests/php-pcre.nix

···
 
 let testString = "can-use-subgroups"; in
 
-import ./make-test.nix ({ pkgs, ...}: {
+import ./make-test.nix ({ ...}: {
   name = "php-httpd-pcre-jit-test";
-  machine = { config, lib, pkgs, ... }: {
+  machine = { lib, pkgs, ... }: {
     time.timeZone = "UTC";
     services.httpd = {
       enable = true;
···
       };
     };
   };
-  testScript = { nodes, ... }:
+  testScript = { ... }:
   ''
     $machine->waitForUnit('httpd.service');
     # Ensure php evaluation by matching on the var_dump syntax

nixos/tests/plasma5.nix

···
     maintainers = [ ttuegel ];
   };
 
-  machine = { lib, ... }:
+  machine = { ... }:
   let
     sddm_theme = pkgs.stdenv.mkDerivation {
       name = "breeze-ocr-theme";

nixos/tests/plotinus.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
 
     { imports = [ ./common/x11.nix ];
       programs.plotinus.enable = true;

nixos/tests/postgis.nix

···
 
   nodes = {
     master =
-      { pkgs, config, ... }:
+      { pkgs, ... }:
 
       {
         services.postgresql = let mypg = pkgs.postgresql100; in {

nixos/tests/postgresql.nix

···
       maintainers = [ zagy ];
     };
 
-    machine = {pkgs, config, ...}:
+    machine = {...}:
       {
         services.postgresql.package=postgresql-package;
         services.postgresql.enable = true;

nixos/tests/powerdns.nix

···
 import ./make-test.nix ({ pkgs, ... }: {
   name = "powerdns";
 
-  nodes.server = { config, pkgs, ... }: {
+  nodes.server = { ... }: {
     services.powerdns.enable = true;
   };
 

nixos/tests/predictable-interface-names.nix

···
     name = "${if predictable then "" else "un"}predictableInterfaceNames${if withNetworkd then "-with-networkd" else ""}";
     meta = {};
 
-    machine = { config, lib, ... }: {
+    machine = { lib, ... }: {
       networking.usePredictableInterfaceNames = lib.mkForce predictable;
       networking.useNetworkd = withNetworkd;
       networking.dhcpcd.enable = !withNetworkd;

nixos/tests/printing.nix

···
   nodes = {
 
     server =
-      { config, pkgs, ... }:
+      { ... }:
       { services.printing.enable = true;
         services.printing.listenAddresses = [ "*:631" ];
         services.printing.defaultShared = true;
···
       };
 
     client =
-      { config, pkgs, nodes, ... }:
+      { ... }:
       { services.printing.enable = true;
       };
 

nixos/tests/prometheus.nix

···
   name = "prometheus";
 
   nodes = {
-    one = { config, pkgs, ... }: {
+    one = { ... }: {
       services.prometheus = {
         enable = true;
         scrapeConfigs = [{

nixos/tests/prosody.nix

···
 import ./make-test.nix {
   name = "prosody";
 
-  machine = { config, pkgs, ... }: {
+  machine = { pkgs, ... }: {
     services.prosody = {
       enable = true;
       # TODO: use a self-signed certificate

nixos/tests/proxy.nix

···
 let
 
   backend =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
 
     { services.httpd.enable = true;
       services.httpd.adminAddr = "[e-mail]";
···
 
   nodes =
     { proxy =
-        { config, pkgs, nodes, ... }:
+        { nodes, ... }:
 
         { services.httpd.enable = true;
           services.httpd.adminAddr = "[e-mail]";
···
       backend1 = backend;
       backend2 = backend;
 
-      client = { config, pkgs, ... }: { };
+      client = { ... }: { };
     };
 
   testScript =

nixos/tests/quagga.nix

···
       nodes = {
 
         client =
-          { config, pkgs, nodes, ... }:
+          { nodes, ... }:
           {
             virtualisation.vlans = [ 1 ];
             networking.defaultGateway = ifAddr nodes.router1 "eth1";
           };
 
         router1 =
-          { config, pkgs, nodes, ... }:
+          { ... }:
           {
             virtualisation.vlans = [ 1 2 ];
             boot.kernel.sysctl."net.ipv4.ip_forward" = "1";
···
           };
 
         router2 =
-          { config, pkgs, nodes, ... }:
+          { ... }:
           {
             virtualisation.vlans = [ 3 2 ];
             boot.kernel.sysctl."net.ipv4.ip_forward" = "1";
···
           };
 
         server =
-          { config, pkgs, nodes, ... }:
+          { nodes, ... }:
           {
             virtualisation.vlans = [ 3 ];
             networking.defaultGateway = ifAddr nodes.router2 "eth1";
···
       };
 
       testScript =
-        { nodes, ... }:
+        { ... }:
         ''
           startAll;
 

nixos/tests/quake3.nix

···
   #makeCoverageReport = true;
 
   client =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
 
     { imports = [ ./common/x11.nix ];
       hardware.opengl.driSupport = true;
···
 
   nodes =
     { server =
-        { config, pkgs, ... }:
+        { pkgs, ... }:
 
         { systemd.services."quake3-server" =
             { wantedBy = [ "multi-user.target" ];

nixos/tests/rabbitmq.nix

···
   };
 
   nodes = {
-    one = { config, pkgs, ... }: {
+    one = { ... }: {
       services.rabbitmq.enable = true;
     };
   };

nixos/tests/radicale.nix

···
 
 in
 
-  import ./make-test.nix ({ pkgs, lib, ... }@args: {
+  import ./make-test.nix ({ lib, ... }@args: {
     name = "radicale";
     meta.maintainers = with lib.maintainers; [ aneeshusa infinisil ];
 

nixos/tests/riak.nix

···
 
   nodes = {
     master =
-      { pkgs, config, ... }:
+      { pkgs, ... }:
 
       {
         services.riak.enable = true;

nixos/tests/run-in-machine.nix

···
 let
   output = runInMachine {
     drv = pkgs.hello;
-    machine = { config, pkgs, ... }: { /* services.sshd.enable = true; */ };
+    machine = { ... }: { /* services.sshd.enable = true; */ };
   };
 in pkgs.runCommand "verify-output" { inherit output; } ''
   if [ ! -e "$output/bin/hello" ]; then

nixos/tests/rxe.nix

···
-import ./make-test.nix ({ pkgs, ... } :
+import ./make-test.nix ({ ... } :
 
 let
-  node = { config, pkgs, lib, ... } : {
+  node = { pkgs, ... } : {
     networking = {
       firewall = {
         allowedUDPPorts = [ 4791 ]; # open RoCE port

nixos/tests/samba.nix

···
 
   nodes =
     { client =
-        { config, pkgs, ... }:
+        { pkgs, ... }:
         { fileSystems = pkgs.lib.mkVMOverride
             { "/public" = {
                 fsType = "cifs";
···
         };
 
       server =
-        { config, pkgs, ... }:
+        { ... }:
         { services.samba.enable = true;
           services.samba.shares.public =
             { path = "/public";

nixos/tests/sddm.nix

···
     default = {
       name = "sddm";
 
-      machine = { lib, ... }: {
+      machine = { ... }: {
         imports = [ ./common/user-account.nix ];
         services.xserver.enable = true;
         services.xserver.displayManager.sddm.enable = true;
···
         maintainers = [ ttuegel ];
       };
 
-      machine = { lib, ... }: {
+      machine = { ... }: {
         imports = [ ./common/user-account.nix ];
         services.xserver.enable = true;
         services.xserver.displayManager.sddm = {
···
         services.xserver.desktopManager.default = "none";
       };
 
-      testScript = { nodes, ... }: ''
+      testScript = { ... }: ''
         startAll;
         $machine->waitForFile("/home/alice/.Xauthority");
         $machine->succeed("xauth merge ~alice/.Xauthority");

nixos/tests/simple.nix

···
     maintainers = [ eelco ];
   };
 
-  machine = { config, pkgs, ... }: {
+  machine = { ... }: {
     imports = [ ../modules/profiles/minimal.nix ];
   };
 

nixos/tests/slim.nix

···
     maintainers = [ aszlig ];
   };
 
-  machine = { pkgs, lib, ... }: {
+  machine = { pkgs, ... }: {
     imports = [ ./common/user-account.nix ];
     services.xserver.enable = true;
     services.xserver.windowManager.default = "icewm";

nixos/tests/slurm.nix

···
-import ./make-test.nix ({ pkgs, ... }:
+import ./make-test.nix ({ ... }:
 let mungekey = "mungeverryweakkeybuteasytointegratoinatest";
     slurmconfig = {
       controlMachine = "control";
···
   nodes =
     let
     computeNode =
-      { config, pkgs, ...}:
+      { ...}:
       {
         # TODO slrumd port and slurmctld port should be configurations and
         # automatically allowed by the  firewall.
···
     in {
 
     control =
-      { config, pkgs, ...}:
+      { ...}:
       {
         networking.firewall.enable = false;
         services.slurm = {
···
       };
 
     submit =
-      { config, pkgs, ...}:
+      { ...}:
       {
         networking.firewall.enable = false;
         services.slurm = {

nixos/tests/smokeping.nix

···
 
   nodes = {
     sm =
-      { pkgs, config, ... }:
+      { ... }:
       {
         services.smokeping = {
           enable = true;

nixos/tests/strongswan-swanctl.nix

···
   meta.maintainers = with pkgs.stdenv.lib.maintainers; [ basvandijk ];
   nodes = {
 
-    alice = { nodes, ... } : {
+    alice = { ... } : {
       virtualisation.vlans = [ 0 ];
       networking = {
         dhcpcd.enable = false;
···
       };
     };
 
-    moon = {pkgs, config, nodes, ...} :
+    moon = { config, ...} :
       let strongswan = config.services.strongswan-swanctl.package;
       in {
         virtualisation.vlans = [ 0 1 ];
···
         };
       };
 
-    carol = {pkgs, config, nodes, ...} :
+    carol = { config, ...} :
       let strongswan = config.services.strongswan-swanctl.package;
       in {
         virtualisation.vlans = [ 1 ];

nixos/tests/subversion.nix

···
 
   nodes =
     { webserver =
-        { config, pkgs, ... }:
+        { ... }:
 
         {
           services.httpd.enable = true;
···
         };
 
       client =
-        { config, pkgs, ... }:
+        { pkgs, ... }:
 
         {
           environment.systemPackages = [ pkgs.subversion ];

nixos/tests/sudo.nix

···
     };
 
     machine =
-      { config, lib, pkgs, ... }:
+      { lib, ... }:
       with lib;
       {
         users.groups = { foobar = {}; barfoo = {}; baz = { gid = 1337; }; };

nixos/tests/switch-test.nix

···
   };
 
   nodes = {
-    machine = { config, lib, pkgs, ... }: {
+    machine = { ... }: {
       users.mutableUsers = false;
     };
-    other = { config, lib, pkgs, ... }: {
+    other = { ... }: {
       users.mutableUsers = true;
     };
   };

nixos/tests/tomcat.nix

···
 
   nodes = {
     server =
-      { pkgs, config, ... }:
+      { ... }:
 
       { services.tomcat.enable = true;
         services.httpd.enable = true;

nixos/tests/tor.nix

···
   meta.maintainers = with maintainers; [ joachifm ];
 
   common =
-    { config, ... }:
+    { ... }:
     { boot.kernelParams = [ "audit=0" "apparmor=0" "quiet" ];
       networking.firewall.enable = false;
       networking.useDHCP = false;
     };
 
   nodes.client =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
     { imports = [ common ];
       environment.systemPackages = with pkgs; [ netcat ];
       services.tor.enable = true;

nixos/tests/trac.nix

···
 
   nodes = {
     storage =
-      { config, pkgs, ... }:
+      { ... }:
       { services.nfs.server.enable = true;
         services.nfs.server.exports = ''
           /repos 192.168.1.0/255.255.255.0(rw,no_root_squash)
···
       };
 
     postgresql =
-      { config, pkgs, ... }:
+      { pkgs, ... }:
       { services.postgresql.enable = true;
         services.postgresql.package = pkgs.postgresql;
         services.postgresql.enableTCPIP = true;
···
       };
 
     webserver =
-      { config, pkgs, ... }:
+      { pkgs, ... }:
       { fileSystems = pkgs.lib.mkVMOverride
           [ { mountPoint = "/repos";
               device = "storage:/repos";
···
       };
 
     client =
-      { config, pkgs, ... }:
+      { ... }:
       { imports = [ ./common/x11.nix ];
         services.xserver.desktopManager.plasma5.enable = true;
       };

nixos/tests/transmission.nix

···
     maintainers = [ coconnor ];
   };
 
-  machine = { config, pkgs, ... }: {
+  machine = { ... }: {
     imports = [ ../modules/profiles/minimal.nix ];
 
     networking.firewall.allowedTCPPorts = [ 9091 ];

nixos/tests/udisks2.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { ... }:
     { services.udisks2.enable = true;
       imports = [ ./common/user-account.nix ];
 

nixos/tests/vault.nix

···
   meta = with pkgs.stdenv.lib.maintainers; {
     maintainers = [ lnl7 ];
   };
-  machine = { config, pkgs, ... }: {
+  machine = { pkgs, ... }: {
     environment.systemPackages = [ pkgs.vault ];
     environment.variables.VAULT_ADDR = "http://127.0.0.1:8200";
     services.vault.enable = true;

nixos/tests/wordpress.nix

···
 
   nodes =
     { web =
-        { config, pkgs, ... }:
+        { pkgs, ... }:
         {
           services.mysql = {
             enable = true;
···
     };
 
   testScript =
-    { nodes, ... }:
+    { ... }:
     ''
       startAll;
 

nixos/tests/xdg-desktop-portal.nix

···
     maintainers = pkgs.xdg-desktop-portal.meta.maintainers;
   };
 
-  machine = { config, pkgs, ... }: {
+  machine = { pkgs, ... }: {
     environment.systemPackages = with pkgs; [ gnome-desktop-testing ];
   };
 

nixos/tests/xfce.nix

···
   };
 
   machine =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
 
     { imports = [ ./common/user-account.nix ];
 

nixos/tests/xmonad.nix

···
     };
   };
 
-  testScript = { nodes, ... }: ''
+  testScript = { ... }: ''
     $machine->waitForX;
     $machine->waitForFile("/home/alice/.Xauthority");
     $machine->succeed("xauth merge ~alice/.Xauthority");

nixos/tests/xrdp.nix

···
   };
 
   nodes = {
-    server = { lib, pkgs, ... }: {
+    server = { pkgs, ... }: {
       imports = [ ./common/user-account.nix ];
       services.xrdp.enable = true;
       services.xrdp.defaultWindowManager = "${pkgs.xterm}/bin/xterm";
       networking.firewall.allowedTCPPorts = [ 3389 ];
     };
 
-    client = { lib, pkgs, ... }: {
+    client = { pkgs, ... }: {
       imports = [ ./common/x11.nix ./common/user-account.nix ];
       services.xserver.displayManager.auto.user = "alice";
       environment.systemPackages = [ pkgs.freerdp ];
···
     };
   };
 
-  testScript = { nodes, ... }: ''
+  testScript = { ... }: ''
     startAll;
 
     $client->waitForX;

nixos/tests/zfs.nix

···
         maintainers = [ adisbladis ];
       };
 
-      machine = { config, lib, pkgs, ... }:
+      machine = { pkgs, ... }:
         {
           virtualisation.emptyDiskImages = [ 4096 ];
           networking.hostId = "deadbeef";

nixos/tests/zookeeper.nix

···
   };
 
   nodes = {
-    server = { pkgs, config, ... }: {
+    server = { ... }: {
       services.zookeeper = {
         enable = true;
       };