Code actions: convert `with lib;` to `let inherit (lib) ...;`, add unknown symbols to inherit

[max-privatevoid]

When writing module options, one ends up using various lib functions, such that using with lib; becomes tempting. Since large-scale with usage is generally considered bad practice, people sometimes opt for an alternative like this:

{ lib, ... }:

let
  inherit (lib) mkOption;
  inherit (lib.types) attrsOf str;
in

{
  options.example = mkOption {
    type = attrsOf str;
    default = { };
  };
}

Since it's annoying to type this out by hand, it would be really nice if nil offered a code action to turn a with into this kind of let-inherit-in construct. It won't be perfect in the case of nested withs, but I think it'll still be worth it for the 80% case.

On top of that, nil could offer a code action similar to the "add to imports" of LSPs in other languages, to easily add new things to the construct. On every unknown symbol, provide code actions such as Inherit this symbol from lib, Inherit this symbol from lib.types for every inherit (from) expression in scope:

{ lib, ... }:

let
  inherit (lib) mkOption;
  inherit (lib.types) attrsOf;
in

{
  options.example = mkOption {
    type = attrsOf str; # <- unknown symbol "str"
    default = { }; # --[ Inherit "str" from lib       ]
  };               # ->[ Inherit "str" from lib.types ]
}

[leana8959]

Hello,

I just tried to implement the "add to inherit" functionality and it seems to work, but I wonder if auto-import upon completion selection would be more ergonomic (which can maybe coexist with the code action).
I can see one reason against this is that it's not actually completing anything but instead auto-importing. However, it does have the benefit of being able to import on the fly during typing.

Here's an example

options.example = mkOption {
  type = attrsOf str|; #   str (from lib)
  default = { };       # > str (from lib.types)
};

Which upon selecting the second entry, str is added to the inherit clause above while the text under cursor doesn't change.

Have a nice day :)

[oxalica]

if auto-import upon completion selection would be more ergonomic

That would be good, but the main problem is that the most top-level parameters cannot be inferred (in your case, lib), which restricts its usefulness.

[leana8959]

Hmm are you saying because lib can't be inferred, we don't know how to insert the inherit (lib) ...; clause?
If that's the case, I thought the scope of adding unknown symbols to inherit only relates to the inherits constructs already present.

My current idea is to walk up from a unknown ref node under cursor and walk up, for each let-inherit-in encountered suggest the user whether to add it there.