Why can't they just fix SHA-1 if it's broken? Presently 160 bits of hash block width seems to provide adequate security against brute force attacks.  The recent developments concerning SHA-1 have reduced the effort to force collisions by 5 orders of magnitude according to the latest Wikipedia edit.

Other cryptographic primitives have been evolved to fix issues that were similarly found, such as:-


RSA -> increasing bit count
RC4 -> RC4A -> Spritz
Whirlpool0 -> WhirlpoolT -> Whirlpool


I'm specifically using the term fix, to mean keeping the SHA-1 160 bit essentials and making internal changes /improvements.  So some (but not limited to) changes might be:-


amending the round count with perhaps double rounds to tie in with the existing key schedule as 80 x 2 instead of 80 x 1
changes to key schedule to increase rounds directly
something akin to internalising SHA-1(SHA-1(message))
additional bit wise operations


Hopefully you get the idea.  Why can't we do this so that it forms a plug in upgrade whereby the existing block size can be kept?  My intention is to easily prolong the life of SHA-1 in existing code and data bases without huge and far reaching programmatic changes.  I realise that 160 bits will someday become insecure requiring it's ultimate replacement by a wider hash.
I have 3 answers: We can't fix SHA-1, we shouldn't fix SHA-1 and we already did fix SHA-1.
SHA-1 is a hash standard; many different people can and have implemented it and they all get the same results. SHA-1 is broken. We have to replace it and convince everybody to move on to a new standard. A fixed SHA-1 wouldn't be SHA-1.
We shouldn't try a minimal fix; we should build the best (fastest, most secure) hash algorithm we can. A minimal fix will keep us with the problematic basic structure of SHA-1. If are switching, we want something which will be secure for many years to come. And be as efficient as possible.

That said, we already fixed it. It's called hardened SHA-1; it is immune to the known and similar collision attacks and it is even backwards compatible with SHA-1, sort of. It detects patterns which will occur in a collision attack and are very rare in random data. Hardened SHA-1 is identical to SHA-1 on almost any input, yet won't be the same and an infinitesimally small portion of inputs we see in collision attacks of the class published.

However though there are no currently known attacks on hardened SHA-1 and it isn't much slower. Nobody has the illusion SHA-1 has competitive security with SHA-2 or SHA-3. 
Even if you need to truncate to 160 bits, these are probably safer options.  If you must have backwards compatibility as a quick fix, Hardened SHA-1 is a great trick but you should make plans to switch to SHA-3