Bash Alias – Precedence and Shadowing Issues

bash

I have some aliases setup (in this order) in .bashrc:

alias ls="lsc"
alias lsc='ls -Flatr --color=always'
alias lscR='ls -FlatrR --color=always'

Confirming them with alias after sourcing:

alias ls='lsc'
alias lsc='ls -Flatr --color=always'
alias lscR='ls -FlatrR --color=always'

I can run the newly aliased ls just fine, and it chains through to the lsc alias, and then executes the command associated with the lsc alias. I can also run lscR and it operates as expected.

If I try to run lsc itself though, I get:

$ lsc
lsc: command not found

Any idea why the shell seems to be shadowing/hiding the lsc alias in this scenario?
(I realise it's pointless to run 'lsc' when I can just run 'ls' to get the same result here, but I'm trying to understand the shells behaviour in this scenario).

EDIT: Workarounds below for the (bash) shell behaviour provided in the question answers.

Some really helpful answers have been provided to the original question. In order to short-circuit the expansion behaviour that is explained in the answers, there seems to be at least two ways of preventing a second alias, from trying to expand a command that you have already aliased. For example, if you have alias cmd='cmd --stuff' which is overriding a native command called cmd, you can prevent the 'cmd' alias from being used in place of the native cmd within other aliases, by:

(thanks to wjandrea's comment for this first approach)

prefixing cmd with 'command' in the other alias e.g. alias other-cmd-alias='command cmd --other-stuff'

or,

Similarly, you can escape aliases (as you can also do on the command line), within other aliases by prefixing with a backslash '', e.g. alias other-cmd-alias='\cmd --other-stuff'.

Best Answer

Bash does allow aliases to contain aliases but it has built-in protections against infinite loops. In your case, when you type lsc, bash first expands the alias to:

ls -Flatr --color=always

Since ls is also an alias, bash expands it to:

lsc -Flatr --color=always

lsc is an alias but, quite sensibly, bash refuses to expand it a second time. If there was a program named lsc, bash would run it. But, there is not and that is why you get command not found.

Addendum

It is different when lscR runs. lscR expands to:

ls -FlatrR --color=always

Since ls is an alias, this expands to:

lsc -FlatrR --color=always

Since lsc is an alias, this expands to:

ls -Flatr --color=always -FlatrR --color=always

Since ls has already been expanded once, bash refuses to expand it a second time. Since a real command called ls exists, it is run.

History

As noted by Schily in the comments, bash borrowed the concept of not expanding an alias a second time from ksh.

Aside

Aliases are useful but not very powerful. If you are tempted to do something complex with an alias, such as argument substitution, don't; use a shell function instead.

Related Solutions

Bash – Does one alias affect another alias

From Aliases (section 6.6 of the Bash Manual):

The first word of each simple command, if unquoted, is checked to see if it has an alias. If so, that word is replaced by the text of the alias.

This happens when you use the alias, not when you define it. Here's an example:

$ alias a1='a2 hello'
$ alias a2='echo'
$ a1
hello
$ unalias a2
$ a1
bash: a2: command not found

Bash Alias – How to Force a Bash Word to Reference an Alias, Function, File, etc.

What you're asking doesn't really make much sense.

keyword means it's a word that is part of the syntax of the shell. Those are recognised through tokenising. Quoting them is enough for the shell to stop recognising.

It is possible to alias a keyword in most shells though. So, aliases have precedence over keywords (in effect they are expanded early, and there is more tokenising after that where you can have more aliases, keywords)...

aliases (with the exception of zsh aliases defined with alias -g are only expanded in command position), so typically not in builtin the-alias.

functions have precedence over builtins, and builtins over external commands (and then $PATH decides which one to use).

You can force the builtin with:

builtin the-cmd and its args

(though it should be noted it is not a standard command).

You can disable aliases by quoting them (though the quoted version could also be aliased in some shells).

So, for instance (here zsh syntax), in:

'while'() echo function while
alias 'while=echo alias while'

Writing while true would actually output alias while true, and there would be no way to use the while keyword since quoting it would disable both the alias and keyword.

You would call the while function with for instance:

'whi'le whatever

If there was a while builtin (but of course their wouldn't in those shells that have while keyword), you'd write it:

builtin while whatever

And to call the while command, you'd write:

env while whatever

or in zsh (when not in sh emulation):

command while whatever

(in other shells, command only prevents functions, not builtins)

/full/path/to/while whatever

Of course, nothing's stopping you from doing even sillier things like:

alias 'while=while "w"hile; do'
"while"() { while "whi"le; done; }

Which, at least in zsh is valid (but stupid).