Haskell generic bash completions break cross-compilation

[roberth]

Issue description

Completions in Haskell currently break cross compilation.

Since #49477 we have a function that does this generically for Haskell packages. This can be improved by either:

• not adding completions when cross compiling
• emulating the behavior of optparse-applicative to generate the very simple scripts in plain bash, which seems feasible. The duplicated logic can then be tested against the native optparse-applicative behavior.

Steps to reproduce

Cross compile a package with completions, like stack. It will call the build output and fail.
Note that stack currently has its own override in hackage2nix, which is probably best to disable in favor of the library functions.

[roberth]

cc @Ericson2314

[Ericson2314]

I would just not do it during cross compilation for. K
Now. We can also copy the output from a native build.

[matthewbauer]

I think disabling makes the most sense. You could use the native-built one but it might end up being incorrect. For instance one option is only available for one architecture or operating system.

[roberth]

It's actually a very very predictable script that does not depend on the options. For this reason, duplicating it in Nix is actually feasible.

It depends only on the executable name/path and the command name.
Source.

Example:

$ nix-shell -p dhall --run 'stack --bash-completion-script dhall'
_stack()
{
    local CMDLINE
    local IFS=$'\n'
    CMDLINE=(--bash-completion-index $COMP_CWORD)

    for arg in ${COMP_WORDS[@]}; do
        CMDLINE=(${CMDLINE[@]} --bash-completion-word $arg)
    done

    COMPREPLY=( $(dhall "${CMDLINE[@]}") )
}

complete -o filenames -F _stack stack

[roberth]

Of course this is a 'nice to have'. We can do without completions on cross.

[stale]

Thank you for your contributions.

This has been automatically marked as stale because it has had no activity for 180 days.

If this is still important to you, we ask that you leave a comment below. Your comment can be as simple as "still important to me". This lets people see that at least one person still cares about this. Someone will have to do this at most twice a year if there is no other activity.

Here are suggestions that might help resolve this more quickly:

1. Search for maintainers and people that previously touched the related code and @ mention them in a comment.
2. Ask on the NixOS Discourse.
3. Ask on the #nixos channel on irc.freenode.net.

[roberth]

The protocol between shell and executable has been fairly stable and the maintainer cares about compatibility, because non-Nix users can have scripts that are out of sync with (upgraded) executables.
Additionally, the protocol may be upgraded to a more forward-compatible form similar to, say, http response headers. See pcapriotti/optparse-applicative#414

[marksisson]

Is there a recommended way to disable the completions for cross compiling?

[roberth]

None of the overrides in nixpkgs seem to handle this.

You could define a function with the same name in the package set pkgs/development/haskell-modules/make-package-set.nix, and make its definition conditional so that it returns an empty string when cross.
Instead of lib.generateOptparseApplicativeCompletion, you'll call super.generateOptparseApplicativeCompletion.