Resolve all aliases in a zsh command line

Question

I have nested aliases and I want to resolve all of them before executing the command. How do I do that?

If there is a function that is not bound to any keys then M-x foobar is fine for me too. I could even use external command (type, command, which, whatever). I tried everything from the thread Why not use "which"? What to use then? but nothing works.

Answer 1

Note that Ctrl-Alt-E in bash does not only expand aliases. It also expands variables, command substitution (!), process substitution (!), arithmetic expand and removes quotes (it doesn't do filename generation (globbing) or tilde expansion).

It doesn't always manage to expand aliases. So while it has its uses, it's important to realise its outcome potentially changes the meaning of the command line, has side effects and is potentially dangerous.

For instance in:

$ a=';w' b=1
$ alias foo=bar
$ b=2; echo $b $a; cd /tmp/dir && for i do foo $(pwd) <(ls); done

If I press M-C-E here, that gives me:

$ b=2; echo 1 ;w; cd /tmp/dir && for i do foo / /dev/fd/63; done

Which gives me a completely different command line altogether (and imagine what would have happened if I had had rm -rf * instead of pwd above) and doesn't expand the foo alias.

With zsh, to build up on Gilles' note on aliases expanded inside functions, you could do:

expand-aliases() {
  unset 'functions[_expand-aliases]'
  functions[_expand-aliases]=$BUFFER
  (($+functions[_expand-aliases])) &&
    BUFFER=${functions[_expand-aliases]#$'\t'} &&
    CURSOR=$#BUFFER
}

zle -N expand-aliases
bindkey '\e^E' expand-aliases

That will expand the aliases only if the current command line is syntactically valid (so it doubles as a syntax checker).

Contrary to bash's M-C-E, it also resolves the aliases fully. For instance if you have:

$ alias ll='ls -l'; alias ls='ls --color'
$ ll

Will be expanded to:

$ ls --color -l

Note that it also canonicalises the syntax so things like:

$ for i (*) cmd $i; foo

will be changed to:

$ for i in *
        do
                cmd $i
        done
        foo

Answer 2

If you stuff a command line into a function definition and then print out the function, the aliases will be expanded. You'll also get normalized whitespace.

% alias foo='bar -1'
% alias bar='qux -2'
% f () foo -3
% which f
f () {
        qux -2 -1 -3
}

To put all this into an interactive command, you can make a zle widget. You can define a function directly by stuffing its code into an entry in the functions array; you'll get the normalization effect when you read back.

normalize-command-line () {
  functions[__normalize_command_line_tmp]=$BUFFER
  BUFFER=${${functions[__normalize_command_line_tmp]#$'\t'}//$'\n\t'/$'\n'}
  ((CURSOR == 0 || CURSOR = #BUFFER)
  unset 'functions[__normalize_command_line_tmp]'
}
zle -N normalize-command-line
bindkey … normalize-command-line

You get the same normalization effect in the preexec hook. Aliases are also expanded at the time a function is autoloaded (autoload -U is commonly used to avoid alias expansion).

The _expand_alias completion function expands the word under the cursor if it's an alias. It uses the aliases array. It is not recursive. You could implement a more general alias expander using aliases, but it is somewhat difficult, because figuring out the locations where aliases are expanded is intimately connected with shell syntax.

Answer 3

If you have many nested fancy aliases and you are not sure what zsh is actually doing with them and in which order options are passed to command then you can always start zsh with -x option. This will print commands and arguments as they are executed.

Be aware however that this option is intended rather for debugging purpose so it prints a lot of useless stuff just after zsh -x invocation (basically each and every function/widget/plugin of your .zshrc), and during command execution it could be also verbose, especially if you have defined preexec and precmd hook.

I should also mention, that it prints only those commands which are finally executed, and separated commands are printed separately so after

alias a='echo a'
alias b='echo b'
alias c='echo c'
alias d='echo d'
a && b || c; d

You will see

+zsh:1> echo a
a
+zsh:1> echo b
b
+zsh:1> echo d
d