Hello, is it possible to get this tool to crates.io and/or homebrew ? That would streamline the installation process greatly (because if I don't use nix on a mac, I have to build it from source). Thanks in advance!

I checked statix today and except for the unquoted splices (#8) and empty pattern I agree with its suggestions on my projects and I'd like to add it to CI.

Though to make any use of it in CI, it is required that we get a non-zero exit code on found suggestions.

I tried statix on my mac, but couldn't because the flake only enables x86_64-linux. I imagine this might be useful to others, so here's a little diff.

Note that the libiconv addition is necessary so that the rust crate compiles on Darwin; I'm not sure why this is different from Linux, but a c compile step fails without it.

Original File:

{ ... }: rec { imports = [ ./console.nix ./firmware.nix ]; }

Lint:

$ statix check
[W10] Warning: Found empty pattern in function argument
   ╭─[./modules/base/default.nix:1:1]
   │
 1 │ { ... }: rec { imports = [ ./console.nix ./firmware.nix ]; }
   · ───┬───  
   ·    ╰───── This pattern is empty, use _ instead
───╯

File after using statix fix:

_: rec { imports = [ ./console.nix ./firmware.nix ]; }

Error:

$ nix flake check
error: module must match an open attribute set ('{ config, ... }')
 … while checking the NixOS module 'nixosModules.base'

Using statix 0.4.0 on NixOS 21.11 with Nix 2.5

Nice tool! I was trying to integrate with null-ls using the json output, however the location output is a bit hard to parse it seems to be character position, an additional row/col output would be nice.

I want to start applying the tool to nixpkgs. For that I would like to disable certain checks or only enable one to keep the changes small and for example only remove extra ().

While debugging a package in nixpkgs I noticed the following oddity: when you format a file which has only comments in the let in, all comments get deleted. Since the comments can be actual code I don't think that is intended.

Before:

_:

let
# those = {};
# are  = {};
# comments = {};
in {}

after:

_:

{}

statix 0.5.4

i happen to have files like this in my project:

• .git/logs/refs/heads/foobar.nix
• .git/logs/refs/remotes/remote-name/foobar.nix

statix will scan them unless explicitly ignored and error-out because these files have nothing to do with nix, it's just branch names with a .nix suffix.

i can tell statix to ignore them using --ignore .git but it appears useful to teach statix to generally avoid .git subfolders, does this make sense?

Currently one has to override the statix package to be able to use the json feature, which again makes it impossible to use through nix run without wrapping the output in an own flake.

This also results in not beeing able to use the cachix.

It therefore would be nice to have an output that has the JSON feature enabled.

Also --format json should not appear in the help if the JSON feature is not available.

[W07] Warning: This function expression is eta reducible
    ╭─[./modules/syncthing.nix:86:13]
    │
 86 │       (map (folder: nameValuePair folder.path folder) foldersOnThisDevice);
    ·             ────────────────────┬───────────────────  
    ·                                 ╰───────────────────── Found eta-reduction: nameValuePair folder.path
────╯

This warning is a false-positive because folder would now be undefined.

Statix should ensure that any removed function arguments do not occur in the remaining expression before it suggests eta-reduction.

Currently it seems as if enabling/disabling individual checks/lints is the only thing supported in the config.toml, this means that I still have to manually maintain a list of ignored files when running statix.

I'd like if this was configurable through the config.toml.

for example:

{
  # statix-ignore
  overlays.default = final: prev: import ./overlay.nix final prev;
}

{
  # statix-ignore: eta_reduction bool_simplification
  overlays.default = final: prev: import ./overlay.nix final prev;
}

If I run statix check on a file or directory, it prints the output:

[bin/src/config.rs:79] [self.ignore.as_slice(), extra_ignores].concat() = []

and nothing else. Looking at that line of code, I can see it is using the dbg! macro to print some debug output that doesn't seem relevant to the end user.

It looks like this might be the expected output if there are no problems with a particular nix file, but it would be nice if there was some explicit acknowledgement that there was nothing wrong with the linted files, rather than just this debug print and exiting.

I started using statix in CI and we ran into a very strange error, I reduced it down to this minimal reproduction:

./${f}.f

This is a valid path, and if f is set to say "foo", then nix would eval it successfully to $PWD/foo.f. To make matters a little stranger, if you run statix fix on this same path it exits with a 0 exit status, no error reported. There must be some divergence between the check logic in the check command, and that in the fix command.

It is possible to inherit attributes from another set[^1]. For example:

let
  x = { a = 1; b = 2; }
  y = { inherit (x) a b; }
in
y # evaluates to `{ a = 1; b = 2; }`

But since Nix does not have maximal laziness, inheriting from the result of a function call will evaluate the function for each inherited attribute. That is, evaluating the expression below:

let
  f = x:
    builtins.trace "evaluated" {
      a = x + 1;
      b = x + 2;
    };
  inherit (f 0) a b;
in
[ a b ]

will evaluate f 0 2 times (which can be checked with trace). This can be avoided with:

let
  f = x:
    builtins.trace "evaluated" {
      a = x + 1;
      b = x + 2;
    };
  set = f 0;
  inherit (set) a b;
in
[ a b ]

In this case f 0 will be evaluated only once because the result is saved in a variable.

[^1]: https://nixos.org/manual/nix/unstable/language/constructs.html#inheriting-attributes

An exception to this is import. While the manual notes that import is a regular function, result of import <path> seems to be cached internally, so:

let
  inherit (import <path>) f g;            # this is OK
  inherit (import <path> <some-args>) f g # this is not OK 
in