I have a bunch of bash completion scripts set up (mostly using bash-it and some manually setup).

I also have a bunch of aliases setup for common tasks like gco for git checkout. Right now I can type git checkout dTab and develop is completed for me but when I type gco dTab it does not complete.

I'm assuming this is because the completion script is completing on git and it fails to see gco.

Is there a way to generically/programmatically get all of my completion scripts to work with my aliases? Not being able to complete when using the alias kind of defeats the purpose of the alias.

  • What OS and bash are you using? I am on Ubuntu 11.10 and bash 4.2.10(1)-release (x86_64-pc-linux-gnu) and I have this functionaity built in to my shell for my many aliases. btw bash --version to get this (don't use -v, different output). – Michael Durrant Jun 16 '12 at 13:14
  • Sorry missed taht bit of info - OSX Lion, GNU bash, version 3.2.48(1)-release (x86_64-apple-darwin11) – dstarh Jun 18 '12 at 13:10
  • 1
    @killermist: unless I’m completely mistaken, zsh doesn’t complete aliased commands out of the box either. Implementing a function that adds defined aliases to completion appears to be much easier than for bash, though, as zhs’s completion system seems both more powerful and more straightforward than bash’s. – kopischke Jun 23 '12 at 19:22
  • 1
    @MichaelDurrant Are you sure that this is actually built in for aliases? I am on Ubuntu 15.10 with Bash 4.3.42(1)-release (x86_64-pc-linux-gnu) and there is no such thing. I also tested a few earlier releases. So for example if you type in ll --[TAB] it will print a list of options for ls? I'm pretty skeptical of this, but if you're sure such a thing existed in 11.10 I'd be curious to dig through it and determine what was removed. – Six Nov 23 '15 at 14:49

The following code, adapted from this Stack Overflow answer and this Ubuntu Forums discussion thread will add completions for all your defined aliases:

# Automatically add completion for all aliases to commands having completion functions
function alias_completion {
    local namespace="alias_completion"

    # parse function based completion definitions, where capture group 2 => function and 3 => trigger
    local compl_regex='complete( +[^ ]+)* -F ([^ ]+) ("[^"]+"|[^ ]+)'
    # parse alias definitions, where capture group 1 => trigger, 2 => command, 3 => command arguments
    local alias_regex="alias ([^=]+)='(\"[^\"]+\"|[^ ]+)(( +[^ ]+)*)'"

    # create array of function completion triggers, keeping multi-word triggers together
    eval "local completions=($(complete -p | sed -Ene "/$compl_regex/s//'\3'/p"))"
    (( ${#completions[@]} == 0 )) && return 0

    # create temporary file for wrapper functions and completions
    rm -f "/tmp/${namespace}-*.tmp" # preliminary cleanup
    local tmp_file; tmp_file="$(mktemp "/tmp/${namespace}-${RANDOM}XXX.tmp")" || return 1

    local completion_loader; completion_loader="$(complete -p -D 2>/dev/null | sed -Ene 's/.* -F ([^ ]*).*/\1/p')"

    # read in "<alias> '<aliased command>' '<command args>'" lines from defined aliases
    local line; while read line; do
        eval "local alias_tokens; alias_tokens=($line)" 2>/dev/null || continue # some alias arg patterns cause an eval parse error
        local alias_name="${alias_tokens[0]}" alias_cmd="${alias_tokens[1]}" alias_args="${alias_tokens[2]# }"

        # skip aliases to pipes, boolean control structures and other command lists
        # (leveraging that eval errs out if $alias_args contains unquoted shell metacharacters)
        eval "local alias_arg_words; alias_arg_words=($alias_args)" 2>/dev/null || continue
        # avoid expanding wildcards
        read -a alias_arg_words <<< "$alias_args"

        # skip alias if there is no completion function triggered by the aliased command
        if [[ ! " ${completions[*]} " =~ " $alias_cmd " ]]; then
            if [[ -n "$completion_loader" ]]; then
                # force loading of completions for the aliased command
                eval "$completion_loader $alias_cmd"
                # 124 means completion loader was successful
                [[ $? -eq 124 ]] || continue
        local new_completion="$(complete -p "$alias_cmd")"

        # create a wrapper inserting the alias arguments if any
        if [[ -n $alias_args ]]; then
            local compl_func="${new_completion/#* -F /}"; compl_func="${compl_func%% *}"
            # avoid recursive call loops by ignoring our own functions
            if [[ "${compl_func#_$namespace::}" == $compl_func ]]; then
                local compl_wrapper="_${namespace}::${alias_name}"
                    echo "function $compl_wrapper {
                        (( COMP_CWORD += ${#alias_arg_words[@]} ))
                        COMP_WORDS=($alias_cmd $alias_args \${COMP_WORDS[@]:1})
                        (( COMP_POINT -= \${#COMP_LINE} ))
                        COMP_LINE=\${COMP_LINE/$alias_name/$alias_cmd $alias_args}
                        (( COMP_POINT += \${#COMP_LINE} ))
                    }" >> "$tmp_file"
                    new_completion="${new_completion/ -F $compl_func / -F $compl_wrapper }"

        # replace completion trigger by alias
        new_completion="${new_completion% *} $alias_name"
        echo "$new_completion" >> "$tmp_file"
    done < <(alias -p | sed -Ene "s/$alias_regex/\1 '\2' '\3'/p")
    source "$tmp_file" && rm -f "$tmp_file"
}; alias_completion

For simple (command only, no arguments) aliases it will assign the original completion function to the alias; for aliases with arguments, it creates a wrapper function that inserts the extra arguments into the original completion function.

Unlike the scripts it has evolved from, the function respects quotes both for the alias command and its arguments (but the former have to be matched by the completion command, and cannot be nested), and it should reliably filter out aliases to command lists and pipes (which are skipped, as it is impossible to find out what to complete in them without re-creating the complete shell command line parsing logic).


Either save the code as a shell script file and source that in, or copy the function wholesale into, .bashrc (or your pertinent dot file). The important thing is to call the function after both bash completion and alias definitions have been set up (the code above calls the function right after its definition, in a “source and forget” spirit, but you can move the call anywhere downstream if that suits you better). If you don’t want the function in your environment after it exits, you can add unset -f alias_completion after calling it.


If you are using bash 4.1 or above and use dynamically-loaded completions, the script will attempt to load completions for all of your aliased commands so that it can build the wrapper functions for your aliases.

  • 1
    How would I go about installing that script? – Der Hochstapler Jun 16 '12 at 10:45
  • 1
    @OliverSalzburg: you’ll have to process it in one of your shell profile files, crucially after bash completion – that would probably make it ~/.bashrc. Either store it as a shell script file and source it (. /path/to/alias_completion.sh), or copy and paste the code wholesale. – kopischke Jun 16 '12 at 12:04
  • 1
    @OliverSalzburg: added usage instructions (didn’t notice right away you are not the OP). – kopischke Jun 16 '12 at 12:27
  • 1
    @kopischke See this question -- apparently for the files under /usr/share/bash-completion/completions/ they are loaded only the first time the user actually hits [TAB]. So even if the function is loaded from ~/.bashrc it will not generate completions for aliases to commands therein. After ensuring complete -p is working for apt-get and apt-cache I copy-pasted your function to the terminal and it is working correctly. – jamadagni Oct 25 '14 at 15:44
  • 1
    @kopischke So I'm not sure how to force sourcing of all the dynamically loaded completion files, or even if it is advisable. For now I have copied the generated completion file from /tmp to ~/.bash_completion and manually added at its beginning the relevant source /usr/share/bash-completion/completions/ entries (separately for apt-get and apt-cache -- apt-{cache,get} doesn't work). – jamadagni Oct 25 '14 at 15:52

Is there a way to generically/programmatically get all of my completion scripts to work with my aliases?

Yes, here is the complete-alias project which solves your problem exactly. It provides generic and programmatic alias completion without using eval.

| improve this answer | |

This is the manual way, for those that are looking for this.

First, look up the original completion command. Example:

$ complete | grep git

complete -o bashdefault -o default -o nospace -F __git_wrap__git_main git

Now add these to your startup script (e.g. ~/.bashrc):

# load dynamically loaded completion functions (may not be required)
_completion_loader git

# copy the original statement, but replace the last command (git) with your alias (g)
complete -o bashdefault -o default -o nospace -F __git_wrap__git_main g

source: https://superuser.com/a/1004334

| improve this answer | |

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.