No bash, como resolver o que realmente será executado?

Supondo que não haja uma solução pronta para uso, expandi a resposta de Jukka Matilainen para incluir a resolução de aliases, recursão e imprimir as etapas.

clevertype ()
{
    input="$1"
    force_file=
    _clevertype() {
        if [[ -n $force_file || "$(type -t "$1")" == "file" ]]; then
            if [[ $(type -p "$1") != "$1" ]]; then
                echo "Resolving from PATH:  $1 -> $(type -P "$1")"
                _clevertype $(type -P "$1")
            elif [[ -L "$1" ]]; then
                echo "Resolving links:      $1 -> $(readlink -e "$(type -p "$1")")"
                _clevertype $(type -P "$(readlink -e "$(type -P "$1")")")
            else
                echo "$input is $1"
            fi
        elif [[ "$(type -t "$1")" == "alias" ]]; then
            echo "Resolving alias:      $1 -> ${BASH_ALIASES[$1]}"
            re="[[:space:]]+"
            force_file=1
            if [[ "${BASH_ALIASES[$1]}" =~ $re ]]; then
              array=(${BASH_ALIASES[$1]})
              _clevertype ${array[0]}
              echo "$input is ${BASH_ALIASES[$1]}"
            else
              _clevertype ${BASH_ALIASES[$1]}
            fi

            
        else
            type "$1"
        fi
    }
    _clevertype "$1"
}

Isso fornece a seguinte saída:

$ clevertype /usr/bin/python3.13
/usr/bin/python3.13 is /usr/bin/python3.13

$ clevertype python3.13
Resolving from PATH:  python3.13 -> /usr/bin/python3.13
python3.13 is /usr/bin/python3.13

$ clevertype python
Resolving from PATH:  python -> /usr/bin/python
Resolving links:      /usr/bin/python -> /usr/bin/python3.13
python is /usr/bin/python3.13

$ clevertype /usr/bin/python3
Resolving links:      /usr/bin/python3 -> /usr/bin/python3.13
/usr/bin/python3 is /usr/bin/python3.13

$ clevertype mypython
Resolving alias:      mypython -> python
Resolving from PATH:  python -> /usr/bin/python
Resolving links:      /usr/bin/python -> /usr/bin/python3.13
mypython is /usr/bin/python3.13

$ clevertype alias1
Resolving alias:      alias1 -> alias2
Resolving alias:      alias2 -> alias3
Resolving alias:      alias3 -> /usr/bin/python
Resolving links:      /usr/bin/python -> /usr/bin/python3.13
alias1 is /usr/bin/python3.13

$ clevertype myfunction
myfunction is a function
myfunction () 
{ 
    echo hello
}

$ clevertype type
type is a shell builtin

$ clevertype mytype
Resolving alias:      mytype -> type
type is a shell builtin

$ clevertype ls
Resolving alias:      ls -> ls --color=auto
Resolving from PATH:  ls -> /usr/bin/ls
ls is /usr/bin/ls
ls is ls --color=auto

Pode haver casos patológicos em que não funciona, pois tenta imitar comportamentos complexos do bash e do sistema operacional. Por exemplo, "ls" é frequentemente um alias para "ls [options]", como pode ser visto no último exemplo. Pode não funcionar se o comando tiver espaços.

Você pode construir isso sozinho: você pode usar readlinkou realpathpara resolver os links recursivamente.

Colocar tudo isso em uma função Bash poderia ser algo assim:

clevertype ()
{
    if [[ "$(type -t "$1")" == "file" ]]; then
        echo "$1 resolves to $(readlink -e "$(type -p "$1")")"
    else
        type "$1"
    fi
}

Esta é minha opinião sobre o que você está pedindo:

llt () 
{ 
    [[ -n $1 ]] || return 1;
    printf -v filetype '%s' $(type -ta $1);
    echo "";
    case $filetype in 
        "")
            echo "llt: $1: not found" 1>&2;
            return 1
        ;;
        *alias*)
            echo "Alias";
            alias "$1" | awk '{sub(/^alias /, ""); print}';
            echo ""
        ;;&
        *function*)
            echo "Shell Function";
            declare -f "$1";
            echo ""
        ;;&
        *builtin*)
            echo "Shell Builtin";
            echo ""
        ;;&
        *keyword*)
            echo "Shell Reserved Word";
            echo ""
        ;;&
        *file*)
            echo "File";
            for fn in $(type -ap $1);
            do
                stat $fn | awk 'NR==1{sub(/^  File: /, ""); print}';
            done
        ;;
    esac
}

No meu Mac, llt lsas saídas são:

Alias
ls='/usr/local/bin/eza'

File
/usr/local/gnubin/ls -> /usr/local/Cellar/coreutils/9.6/libexec/gnubin//ls
/bin/ls

O inicial printfcriará uma linha com base no type -ta $1ie. aliasfilefile Cada teste da instrução case executará o teste e ;;&dirá à instrução case para continuar no próximo teste (então o exemplo atingirá o aliasteste e o fileteste.

Esqueci de mencionar se o comando é um alias ou função, eu produzo o conteúdo desse alias ou função